list

 

1.集合　

 

　　数组长度是固定,当添加的元素超过了数组的长度时须要对数组从新定义,太麻烦,java内部给咱们提供了集合类,能存储任意对象,长度是能够改变的,随着元素的增长而增长,随着元素的减小而减小

 

2.数组和集合的区别

　　数组：既能够存储基本数据类型，又能够储存引用数据类型，基本数据类型存储的是值，引用数据类型存储的是地址值

　　集合：只能存储引用数据类型（对象）集合中也能够存储基本数据类型，可是在存储的时候会自动装箱变成对象（Integer, Double)　

　　数组长度是固定的，不能自动增加

　　集合的长度是能够变的，能够根据元素的增加而增加　

 

3.数组集合是何时用

　　若是元素个数是固定的推荐数组

　　若是元素个数不是固定的推荐用集合（用处会不少）

 

4.Collection 集合的基本功能测

 

　　Collection集为单列集合

　　下有两个分支   list和set　　list又有ArrayLise ，LinkedList，vecort　　Set又有 Hashsete 和treeset

　　list集合内add方法永远返回true，也就是说什么类型的数据均可以添加进去

 

 1             public static void demo2() {
 2                 //Collection是接口，因此须要父类引用指向子类对象
 3                 Collection c = new ArrayList();
 4                 //add（）方法将元素添加到列表尾部
 5                 c.add("a");
 6                 c.add("b");
 7                 c.add("c");
 8                 c.add("d");
 9                 //remove（）方法是删除
10                 boolean b = c.remove("a");
11                 System.out.println(b);  // true
12                 System.out.println(c);  // b c d
13                 
14                 //清空集合
15                 c.clear(); 
16                 System.out.println(c);
17                 //判断集合是否包含“c”
18                 boolean b1 = c.contains("c"); 
19                  System.out.println(b1);
20                //判断集合是否为空
21                 System.out.println(c.isEmpty());
22                 //获取元素个数
23                 int a = c.size();
24                 System.out.println(a);
25                 
26             }

 

5.集合转数组遍历

 

　　

 1  　　　　Collection c = new ArrayList();
 2         c.add("a");
 3         c.add("b");
 4         c.add("c");
 5         c.add(5);
 6         
 7         //Collection接口中包含了toSArray方法
 8         //把集合转换成数组，Object类型的数组，再用for循环遍历
 9         Object []obj = c.toArray();
10         for (int i = 0; i < obj.length; i++) {
11             System.out.println(obj[i]);
12         }

 1         //输出自定义对象，和存储自定对象的方法
 2         Collection c = new ArrayList();
 3         c.add(new Student("z",34));
 4         c.add(new Student("x",45));
 5         c.add(new Student("s",23));
 6         
 7         //将集合转为数组，
 8         Object []obj = c.toArray();
 9         for (Object object : obj) {
10             //getset方法输出
11             System.out.println(object);
12         }
13         for (int i = 0; i < obj.length; i++) {
14             //向下转型，转到Student类中，调用getset方法，这样就能够本身输出内容
15             Student s = (Student)obj[i];
16             System.out.println(s.getName() + " " + s.getAge());

 

6.Collection集合自带All功能测试

　　

 1         Collection c = new ArrayList();
 2         c.add("c");
 3         c.add("b");
 4         c.add("a");
 5         Collection c1 = new ArrayList();
 6         c1.add("c");
 7         c1.add("b");
 8         c1.add("a");
 9         
10         //addAll是把c1中每个元素都添加到c中，添加一个元素c长度加一
11         c.addAll(c1);
　　　　　　//输出结果为[c, b, a, c, b, a]  长度6
12         
13         //add是把c1做为一个对象，多为一个总体，直接添加到c中，c1添加进去够c的长度只加1
14         c.add(c1);
　　　　　　//输出结果为[c, b, a,[c, b, a]]  长度4

 

 1     Collection c = new ArrayList();
 2         c.add("c");
 3         c.add("b");
 4         c.add("a");
 5         Collection c1 = new ArrayList();
 6         c1.add("c");
 7         c1.add("b");
 8 9         
10         //删除  调用集合与传入集合的交集
11         c.removeAll(c1);
12         System.out.println(c);
13         //输出结果  a

        Collection c = new ArrayList();
        c.add("c");
        c.add("b");
        c.add("a");
        Collection c1 = new ArrayList();
        c1.add("c");
        c1.add("b");
//判断调用集合是否包含传入集合
        c.containsAll(c1);

 1         Collection c = new ArrayList();
 2         c.add("c");
 3         c.add("b");
 4         c.add("a");
 5         Collection c1 = new ArrayList();
 6         c1.add("c");
 7         c1.add("b");
 9         
10         //若是调用集合改变，就返回true，若是调用者没改变，就返回false
11         
12         c.retainAll(c1);//取调用集合和录入集合的交集，输出调用者的话，是不会输出出来两个集合之间的交集
13         System.out.println(c);
14         //输出结果  a

 

7.迭代器遍历

 1     Collection c = new ArrayList();
 2         c.add("c");
 3         c.add("b");
 4         c.add("a");
 5         //使用迭代器进行遍历
 6         Iterator iter = c.iterator();
 7         //hasNext是判断还有没有下一个元素
 8         while(iter.hasNext()) {
 9             //next是输出下一个元素
10             System.out.println(iter.next());
11         }

 1    //遍历自定义对象


　　　　 Iterator iter = c.iterator();
 2 
 3      while(iter.hasNext()) {
 4              System.out.println(iter.next());
 5      }
 6      
 7      /*输出结果
 8       * Student [name=z, age=34]
 9       * Student [name=x, age=45]
10       * Student [name=s, age=23]
11       */
12      
13         
14      while(iter.hasNext()) {
15         Student s = (Student)iter.next();
16         System.out.println(s.getName() + " " + s.getAge());
17  }
18         /*输出结果
19          *  z 34
20          *  x 45
21          *  s 23
22          */
23         

 

1  //  size是集合长度
2     for (int i = 0; i <list.size(); i++) {
3                 //System.out.println(list.get(i));
4                 Student s= (Student)list.get(i);
5                 System.out.println(s.getName()+"..."+s.getAge());

 　　

8.并发修改异常产生的缘由和解决方案

　　naex（）；方法在一个循环中只容许使用一次，不然会对是数据

 1 /*
 2          * 判断集合中有没有word元素，若是有就添加javaee，
 3          */
 4         List list = new ArrayList();
 5         list.add("a");
 6         list.add("word");        
 7         list.add("c");
 8         list.add("b");
 9         
10         //迭代器添加元素
11         ListIterator lis = list.listIterator();
12         while (lis.hasNext()) {
13             //向下转型到string类
14             String str = (String)lis.next();
15             //进行判断
16             if (str.equals("word")) {
17                 //这是使用迭代器去添加元素，而不是list自己去添加
18                 lis.add("javaee");
19             }
20             
21         }
22         
23         System.out.println(list);
24         //输出结果为 [a, word, javaee, c, b]

 

9.vector特有功能

老师没讲，vector会被Arraylist代替，可是须要知道油脂和气个东西

，代码也插一下

 1     public static void demo() {
 2         Vector v = new Vector(); // 建立集合对象,List的子类
 3         v.add("a"); // 在集合出现后，为了实现list的接口，添加的功能
 4         v.addElement("a"); // Vector类出现自己就有的特有的功能
 5         v.addElement("b");
 6         v.addElement("c");
 7         v.addElement("d");
 8 
 9         // Vector迭代s
10         Enumeration en = v.elements(); // 获取枚举
11         while (en.hasMoreElements()) { // 判断集合中是否有元素
12             System.out.println(en.nextElement());// 获取集合中的元素
13         }
14     }

10.数据结构之链表和数组（须要背下来，知识点）

　　数组是：查询快修改快，增删慢

　　链表是，查询慢修改慢，增删快

 

11.list类的三个子类的特色（须要背，知识点）

　　ArrayList：

　　　　　　底层数据结构是数组，查询快 ，增删慢，

　　　　　　线程不安全，效率高

 

　　LinkedList：

　　　　　　底层数据结构是链表，查询慢，增删快

　　　　　　线程不安全，效率高

 

　　Vector:

　　　　　　底层数据结构是数组，查询快，增删慢。

　　　　　　线程安全，效率低

　　　　　　Vector 相对于 ArrayList 查询慢（线程安全）

　　　　　　　　　相对于 LinkedList 增删慢 （数组结构）

 

　　Vector 和 ArrayList 的区别：

　　　　　　Vector是线程安全效率低

　　　　　　ArrayList是线程不安全效率高

　　　　　　共同点：都是数组实现的

　　

　　ArrayList和LinkedList的区别：

　　　　　　ArrayList 底层是是数组结果 查询快，增删慢

　　　　　　LinkedList  底层是链表结果 查询慢，增删快

　　　　　　共同点：线程都是不安全的

 

　　List的三个儿子：

　　　　　　查询多，增删慢用ArrayList

　　　　　　增删多，查询慢用 linkedList

　　　　　　若是都多就用 ArraayList