Java暑期学习Day36

马太效应

今天是第36天，鼠标终于可以正常使用了

                               
登录/注册后可看大图

① ArrayList


构造方法

ArrayList()	构造一个初始容量为十的空列表。
ArrayList(Collection<? extends E> c)	构造一个包含指定集合的元素的列表， 按照它们由集合的迭代器返回的顺序。
ArrayList(int initialCapacity)	构造具有指定初始容量的空列表。

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;


public class ArrayListDemo {

        public static void main(String[] args) {
                /*
                 * 当我们调用无参数构造方法来构造一个ArrayList对象的时候
                 * 它会在内部分配一个初始大小为10的一个Object类型的数组
                 * 
                 * 当添加的数据容量超过数组大小的时候，会产生一个新的数组，
                 * 新的数组大小为原来数组大小的1.5倍，接着把原数组中的数据
                 * 拷贝到新的数组中
                 * 
                 * 
                 */
                List<String> nList=new ArrayList<String>();
                nList.add("panda");
                nList.add("apple");
                nList.add("banana");
                nList.add("peal");
                nList.add(1,"fish");
                nList.set(0, "Apanda");
                System.out.println("使用迭代器对象来进行统一的遍历");
       Iterator<String> it=nList.iterator();
       while(it.hasNext()){
               String name=it.next();
               System.out.println(name);
       }
               System.out.println("使用增持for循环进行遍历");
               for(String name1:nList){
                       System.out.println(name1);
               }
               
               System.out.println("********************");
               System.out.println(nList.indexOf("peal"));
               System.out.println(nList.remove("Apanda"));
               System.out.println(nList.remove(0));
               System.out.println(nList.size());
               System.out.println(nList.contains("Apanda"));
               System.out.println(nList.get(0));
               System.out.println(nList.isEmpty());
               nList.clear();
               System.out.println(nList.isEmpty());
       
        }

}

结果是——
使用迭代器对象来进行统一的遍历
Apanda
fish
apple
banana
peal
使用增持for循环进行遍历
Apanda
fish
apple
banana
peal
********************
4
true
fish
3
false
apple
false
true

1.数组在内存中是连续的线性空间，根据索引随机存取的速度快，如排序时使用。
2.在ArrayList内部数组长度不够时，会建立新数组，并将旧的数组的参考指定给新的数组。

import java.util.ArrayList;
import java.util.List;


public class ArrayListDemo2 {

        public static void main(String[] args) {
                List<Student> stuList=new ArrayList<Student>();
                Student stu1= new Student("zs",10);
                Student stu2= new Student("ls",20);
                Student stu3= new Student("jk",30);
                Student stu4= new Student("my",10);
                Student stu5= new Student("ry",20);
                
                stuList.add(stu1);
                stuList.add(stu2); 
                stuList.add(stu3);
                stuList.add(stu4);
                stuList.add(stu5);
                Student stu6=new Student("my",10);
                System.out.println(stuList.indexOf(stu6));
                System.out.println(stuList.contains(stu6));
                System.out.println(stuList.remove(stu6));
                System.out.println(stuList.indexOf(stu4));
                System.out.println(stuList.size());
        
                

        }

}
class Student{
        private String name;
        public Student(String name, int age) {
                super();
                this.name = name;
                this.age = age;
        }
        private int age;
        public String getName() {
                return name;
        }
        public void setName(String name) {
                this.name = name;
        }
        public int getAge() {
                return age;
        }
        public void setAge(int age) {
                this.age = age;
        }
        
        @Override
        public boolean equals(Object obj) {
                if (this == obj)
                        return true;
                if (obj == null)
                        return false;
                if (getClass() != obj.getClass())
                        return false;
                Student other = (Student) obj;
                if (age != other.age)
                        return false;
                if (name == null) {
                        if (other.name != null)
                                return false;
                } else if (!name.equals(other.name))
                        return false;
                return true;
        }
}

结果是——
3
true
true
-1
4

3.语法细节
ArrayList 的父类是 AbstractList。

AbstractList的唯一构造方法的详细信息：
protected AbstractList()唯一的构造函数。
（用于子类构造函数的调用，通常是隐式的。）


-！-
public String toString()
    返回对象的字符串表示形式。 一般来说， toString方法返回一个“textually代表”这个对象的字符串。 结果应该是一个简明扼要的表达，容易让人阅读。 建议所有子类覆盖此方法。

    该toString类方法Object返回一个由其中的对象是一个实例，该符号字符`的类的名称的字符串@ ”和对象的哈希码的无符号的十六进制表示。 换句话说，这个方法返回一个等于下列值的字符串：
    getClass().getName() + '@' + Integer.toHexString(hashCode())

    结果——对象的字符串表示形式

② LinkedList--链表

All implemented Interfaces:

Serializable (可串行化的)

Cloneable  （可复制的）

Iterable<E> （可迭代的）

Collection<E> （集合）

Deque<E> （双端队列）

List<E> (序列)

Queue <E> （队列）

构造方法

LinkedList()	构造一个空列表。
LinkedList(Collection<? extends E> c)	构造一个包含指定集合的元素的列表， 按照它们由集合的迭代器返回的顺序。

1.LinkedList类扩展AbstractSequentialList(其父类)并实现List和Deque接口<JDK8.0视角>。
2.LinkedList提供了一个链表数据结构。
3.除了继承的方法之外，LinkedList类还定义了一些有用的方法用于操作和访问容器中的数据。

4.LinkedList在操作List接口时，采用了链接结构，不会事先耗费内存，想要指定索引随机存取对象时，会比较没有效率，链接的每个元素会参考下一个元素，这有利于调整索引顺序。

import java.util.Iterator;
import java.util.LinkedList;

public class LinkedListDemo1 {

        /*
         * LinkedList它内部封装的是双向链表
         * 数据结构每个节点是一个Node对象，Node对象中封装的是你要添加的元素
         * 还有一个指向上一个Node对象的引用和指向下一个Node对象的引用
         * 
         * 不同的容器有不同的数据结构，不同的数据结果操作起来性能 是不一样的
         * 
         * 链接数据结构，做插入、删除的效率比较高，但查询效率较低
         * 
         * 数组结构，它做查询的时候效率高，因为可以通过下表直接找到元素 但插入和删除效率比较低，因为要做移位操作
         */
        public static void main(String[] args) {
                LinkedList<String> sList = new LinkedList<String>();
                sList.add("zs");
                sList.add("ls");
                sList.add("wu");
                sList.add("rs");
                sList.add("my");
                sList.add("jk");
                sList.addFirst("panda");
                sList.addLast("mandy");
                Iterator<String> it = sList.iterator();
                while (it.hasNext()) {
                        String name = it.next();
                        System.out.println(name);
                }
                System.out.println("*****************************************");
                for (Iterator<String> it2 = sList.iterator(); it2.hasNext();) {
                        String name = it2.next();
                        System.out.println(name);

                }
                System.out.println("*****************************************");
                for (String name : sList) {
                        System.out.println(name);
                }
                System.out.println(sList.removeFirst());
                System.out.println(sList.size());
                sList.clear();
                System.out.println(sList.pollFirst());
                System.out.println(sList.size());

        }

}

结果是——
panda
zs
ls
wu
rs
my
jk
mandy
*****************************************
panda
zs
ls
wu
rs
my
jk
mandy
*****************************************
panda
zs
ls
wu
rs
my
jk
mandy
panda
7
null
0