java基础学习_集合类01_对象数组、集合Collection接口、集合List接口

java基础学习_集合类01_对象数组、集合Collection接口、集合List接口_day15总结

2018-03-19 713

=============================================================================
=============================================================================
涉及到的知识点有：
1:对象数组的概述和案例(掌握)
　　(1)对象数组的概述
　　(2)对象数组的案例
2:集合(Collection接口)(掌握)
　　(1)集合的由来？
　　(2)集合和数组的区别？
　　(3)集合的继承体系结构
　　(4)Collection接口的概述
　　(5)Collection接口的成员方法(注意：默认方法前有public abstract修饰)
　　(6)Collection集合的遍历
　　(7)迭代器
　　(8)Collection集合的案例(遍历方式：迭代器方式)(要求：用记事本默写)
　　　　A:存储字符串并遍历
　　　　B:存储自定义对象并遍历
3:集合(List接口)(掌握)
　　(1)List是Collection的子接口
　　(2)List的特有功能(注意：默认方法前有public abstract修饰)
　　(3)List集合的特有遍历功能
　　(4)列表迭代器的特有功能(了解)
　　(5)ConcurrentModificationException 并发修改异常
　　(6)常见的数据结构以及其优缺点
　　(7)List的子类特点(面试题)
　　(8)List集合的案例(遍历方式迭代器和普通for循环)
=============================================================================
=============================================================================
1:对象数组的概述和案例(掌握)
　　(1)对象数组的概述
　　　　数组既可以存储基本数据类型，也可以存储引用类型。它存储引用类型的时候的数组就叫对象数组。
　　(2)对象数组的案例
　　　　我有5个学生，请把这个5个学生的信息存储到数组中，并遍历学生数组，获取得到每一个学生的信息。

　　　　示例代码如下：

 1 package cn.itcast_01;
 2 
 3 public class Student {
 4     // 成员变量
 5     private String name;
 6     private int age;
 7 
 8     // 构造方法
 9     public Student() {
10         super();
11     }
12 
13     public Student(String name, int age) {
14         super();
15         this.name = name;
16         this.age = age;
17     }
18 
19     // 成员方法
20     // getXxx()/setXxx()
21     public String getName() {
22         return name;
23     }
24 
25     public void setName(String name) {
26         this.name = name;
27     }
28 
29     public int getAge() {
30         return age;
31     }
32 
33     public void setAge(int age) {
34         this.age = age;
35     }
36 
37     @Override
38     public String toString() {
39         return "Student [name=" + name + ", age=" + age + "]";
40     }
41 }

Student.java

 1 package cn.itcast_01;
 2 
 3 /*
 4  * 我有5个学生，请把这个5个学生的信息存储到数组中，并遍历学生数组，获取得到每一个学生的信息。
 5  *         学生类：Student
 6  *             成员变量：name,age
 7  *             构造方法：无参,带参
 8  *             成员方法：getXxx()/setXxx()
 9  *         存储学生的数组？自己想想应该是什么样子的？
10  * 分析：
11  *         A:创建学生类。
12  *         B:创建学生数组(对象数组)。
13  *         C:创建5个学生对象，并赋值。
14  *         D:把C步骤的元素，放到学生数组中。
15  *         E:遍历学生数组。
16  */
17 public class ObjectArrayDemo {
18     public static void main(String[] args) {
19         // 创建学生数组(对象数组)。
20         Student[] students = new Student[5];
21         
22         // 遍历新创建的学生数组。
23         for (int x = 0; x < students.length; x++) {
24             System.out.println(students[x]);
25         }
26         System.out.println("---------------------");
27 
28         // 创建5个学生对象，并赋值。
29         Student s1 = new Student("林青霞", 27);
30         Student s2 = new Student("风清扬", 30);
31         Student s3 = new Student("刘意", 30);
32         Student s4 = new Student("赵雅芝", 60);
33         Student s5 = new Student();
34         s5.setName("王力宏");
35         s5.setAge(27);
36         
37         // 把C步骤的元素，放到学生数组中。
38         students[0] = s1;
39         students[1] = s2;
40         students[2] = s3;
41         students[3] = s4;
42         students[4] = s5;
43 
44          // 看到很相似，就想用循环改，把C步骤的元素，放到学生数组中。
45          // for (int x = 0; x < students.length; x++) {
46          //      students[x] = s + "" + (x + 1); // 拼完之后是一个字符串了。
47          // }
48          // 这个是有问题的。
49 
50         // 遍历赋值后的学生数组，用重写的toString()方法
51         for (int x = 0; x < students.length; x++) {
52             // 重写toString()方法，注意：一个方法写定之后就不要再去改变了。因为改来改去的还不如重新写个方法呢？
53             System.out.println(students[x]); 
54         }
55         System.out.println("---------------------");
56         
57         // 遍历赋值后的学生数组，用getXxx()方法
58         for (int x = 0; x < students.length; x++) {            
59             // System.out.println(students[x].getName() + "---" + students[x].getAge()); // 或者等价于下面
60             // 因为学生数组的每一个元素都是一个学生。
61             Student s = students[x];
62             System.out.println(s.getName() + "---" + s.getAge());
63         }
64     }
65 }

ObjectArrayDemo.java

-----------------------------------------------------------------------------
2:集合(Collection接口)(掌握)
　　(1)集合的由来？
　　　　我们学习的是Java --> 面向对象 --> 操作很多对象 --> 存储 --> 容器(数组和StringBuffer) --> 数组
　　　　而数组的长度是固定的，当添加的元素超过了数组的长度需要对数组重新定义，太麻烦，所以数组不适合做变化的需求，Java内部就给我们提供了集合类供我们使用。
　　　　集合类能存储任意对象，长度是可以该变的，即长度能随着元素的增加而增加，随着元素的减少而减少。
　　(2)集合和数组的区别？
　　　　A:长度区别
　　　　　　数组长度固定，不能自动增长。
　　　　　　集合的长度的是可变的,可以根据元素的增加而增长。
　　　　B:内容区别
　　　　　　数组只能存储同一种类型。
　　　　　　集合可以存储不同类型(其实集合一般存储的也是同一种类型)。
　　　　C:元素的数据类型区别
　　　　　　数组既可以存储基本数据类型，又可以存储引用数据类型；基本数据类型存储的是值，引用数据类型存储的是地址值。
　　　　　　集合只能存储引用数据类型(对象)，其实集合中也可以存储基本数据类型，但是在存储的时候会自动装箱变成对象。
---------------------------------------
　　(3)集合的继承体系结构
　　　　刚说过集合是存储多个元素的，但是呢，存储多个元素我们也是有不同需求的：
　　　　　　比如说，我要这多个元素中不能有相同的元素；
　　　　　　再比如说，我要这多个元素按照某种规则排序一下。
　　　　针对不同的需求，Java就提供了不同的集合类，这样呢，Java就提供了很多个集合类。
　　　　　　这多个集合类的数据结构不同，数据结构不同不重要的，重要的是你要能够存储东西，并且还要能够使用这些东西，比如说存储、获取、判断等。
　　　　　　既然这样，那么，这多个集合类是有共性的内容的，我们把这些集合类的共性内容不断的向上提取，最终就能形成集合的继承体系结构。
　　　　如下图所示：

　　　　
　　Collection(单列集合的根接口)
　　　　|--List(有序:存和取的顺序一致,有索引,可以存储重复元素)
　　　　　　|--ArrayList(数组实现)
　　　　　　|--Vector(数组实现)
　　　　　　|--LinkedList(链表实现)
　　　　|--Set(无序:存和取的顺序不一致,无索引,不可以存储重复元素)
　　　　　　|--HashSet(哈希算法)
　　　　　　|--TreeSet(二叉树算法)
---------------------------------------
　　(4)Collection接口的概述
　　　　Collection接口是集合的顶层接口，它的子体系有重复的，有唯一的，有有序的，有无序的。(后面会慢慢的讲解)
　　　　Collection表示一组对象，这些对象也称为collection的元素。
　　　　JDK不提供此接口的任何直接实现：它提供更具体的子接口（如 Set 和 List）实现。
　　(5)Collection接口的成员方法(注意：默认方法前有public abstract修饰)
　　　　1：添加功能
　　　　　　boolean add(Object obj)　　添加一个元素
　　　　　　boolean addAll(Collection c) 添加一个集合的元素
　　　　2:删除功能
　　　　　　void clear() 　　　　　　　　　移除所有元素
　　　　　　boolean remove(Object o) 　　移除一个元素
　　　　　　boolean removeAll(Collection c) 移除一个集合的元素(只要集合中有一个元素被移除了，就返回true)
　　　　3:判断功能
　　　　　　boolean contains(Object o) 　　判断集合中是否包含指定的元素
　　　　　　boolean containsAll(Collection c) 判断集合中是否包含指定的集合元素(只有集合包含所有的元素，才返回true，才叫包含)
　　　　　　boolean isEmpty() 　　　　　　判断集合是否为空
　　　　4:获取功能(重点学)
　　　　　　Iterator<E> iterator() 　返回在此集合的元素上进行迭代的迭代器。是集合专用的遍历方式。
　　　　5:长度功能
　　　　　　int size() 　　元素的个数（即集合的长度）
　　　　　　面试题：
　　　　　　　　数组有没有length()方法呢？答：没有。特别注意：因为数组求长度是：数组名.length，而不是：数组名.length()
　　　　　　　　字符串有没有length()方法呢？答：有。
　　　　　　　　集合有没有length()方法呢？答：没有，因为集合求长度的方法是size()。
　　　　6:交集功能(了解)
　　　　　　boolean retainAll(Collection c) 　　两个集合都有的元素？思考：元素去哪了？返回的boolean又是什么意思呢？
　　　　　　　　// 假设有两个集合A，B。
　　　　　　　　// A对B做交集，最终的结果保存在集合A中，集合B不变。
　　　　　　　　// 但是返回值表示的是集合A是否发生过改变。
　　　　　　　　// 集合A没有发生改变，返回false，即集合B包含集合A；
　　　　　　　　// 集合A发生改变，返回true。
　　　　7：把集合转成对象数组，可以实现集合的遍历(了解)
　　　　　　Object[] toArray()
---------------------------------------
　　(6)Collection集合的遍历
　　　　A:把集合转成对象数组(了解)
　　　　　　练习：用集合存储5个学生对象，并把学生对象进行遍历(遍历方式：把集合转成对象数组，需要用记事本背着写出来)。
　　　　　　示例代码如下：

 1 package cn.itcast_02;
 2 
 3 public class Student {
 4     // 成员变量
 5     private String name;
 6     private int age;
 7 
 8     // 构造方法
 9     public Student() {
10         super();
11     }
12 
13     public Student(String name, int age) {
14         super();
15         this.name = name;
16         this.age = age;
17     }
18 
19     // 成员方法
20     // getXxx()/setXxx()
21     public String getName() {
22         return name;
23     }
24 
25     public void setName(String name) {
26         this.name = name;
27     }
28 
29     public int getAge() {
30         return age;
31     }
32 
33     public void setAge(int age) {
34         this.age = age;
35     }
36 }

Student.java

 1 package cn.itcast_02;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Collection;
 5 
 6 /*
 7  * 练习：用集合存储5个学生对象，并把学生对象进行遍历(遍历方式：把集合转成对象数组，需要用记事本背着写出来)。
 8  * 
 9  * 分析：
10  *         A:创建学生类
11  *         B:创建集合对象
12  *         C:创建学生对象
13  *         D:把学生添加到集合
14  *         E:把集合转成对象数组
15  *         F:遍历对象数组
16  */
17 public class StudentDemo {
18     public static void main(String[] args) {
19         // 创建集合对象
20         Collection c = new ArrayList();
21 
22         // 创建学生对象
23         Student s1 = new Student("林青霞", 27);
24         Student s2 = new Student("风清扬", 30);
25         Student s3 = new Student("令狐冲", 33);
26         Student s4 = new Student("武鑫鑫", 25);
27         Student s5 = new Student("刘晓曲", 22);
28 
29         // 把学生添加到集合
30         c.add(s1);
31         c.add(s2);
32         c.add(s3);
33         c.add(s4);
34         c.add(s5);
35 
36         // 把集合转成对象数组，向上转型
37         Object[] objs = c.toArray();
38         // 遍历对象数组
39         for (int x = 0; x < objs.length; x++) {
40             // System.out.println(objs[x]); // 没有重写toString()方法
41 
42             // 向下转型
43             Student s = (Student) objs[x];
44             System.out.println(s.getName() + "---" + s.getAge());
45         }
46     }
47 }

StudentDemo.java　　　

　　　　B:迭代器(集合的专用遍历方式)
　　　　　　练习：用集合存储5个学生对象，并把学生对象进行遍历(遍历方式：用迭代器进行遍历)。
　　　　　　示例代码如下：

 1 package cn.itcast_03;
 2 
 3 public class Student {
 4     // 成员变量
 5     private String name;
 6     private int age;
 7 
 8     // 构造方法
 9     public Student() {
10         super();
11     }
12 
13     public Student(String name, int age) {
14         super();
15         this.name = name;
16         this.age = age;
17     }
18 
19     // 成员方法
20     // getXxx()/setXxx()
21     public String getName() {
22         return name;
23     }
24 
25     public void setName(String name) {
26         this.name = name;
27     }
28 
29     public int getAge() {
30         return age;
31     }
32 
33     public void setAge(int age) {
34         this.age = age;
35     }
36 
37     @Override
38     public String toString() {
39         return "Student [name=" + name + ", age=" + age + "]";
40     }
41     
42 }

Student.java

 1 package cn.itcast_03;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Collection;
 5 import java.util.Iterator;
 6 
 7 /*
 8  * 练习：用集合存储5个学生对象，并把学生对象进行遍历。用迭代器进行遍历。
 9  * 
10  * 注意：
11  *         A:自己的类名不要和我们学习的要使用的API中的类名相同。
12  *         B:复制代码的时候，很容易把那个类所在的包也导入过来，容易出现不能理解的问题。
13  */
14 public class IteratorTest {
15     public static void main(String[] args) {
16         // 创建集合对象
17         Collection c = new ArrayList();
18 
19         // 创建学生对象
20         Student s1 = new Student("林青霞", 27);
21         Student s2 = new Student("风清扬", 30);
22         Student s3 = new Student("令狐冲", 33);
23         Student s4 = new Student("武鑫鑫", 25);
24         Student s5 = new Student("刘晓曲", 22);
25 
26         // 把学生添加到集合中
27         c.add(s1);
28         c.add(s2);
29         c.add(s3);
30         c.add(s4);
31         c.add(s5);
32 
33         // 遍历
34         Iterator it = c.iterator();
35         while (it.hasNext()) {
36             // System.out.println(it.next()); // 重写了toString()方法
37             Student s = (Student) it.next();  // 向下转型
38             System.out.println(s.getName() + "---" + s.getAge());
39         }
40     }
41 }

IteratorTest.java

　　　　　　迭代器使用出现的2个想问题解释：
　　　　　　　　问题1:能用while循环写这个程序，我能不能用for循环呢？
　　　　　　　　　　答：能。用for循环改写，遍历完成后，it这个对象就变成垃圾了，可以被JVM的垃圾回收器进行回收了，效率高，但是结构不是特别明朗。
　　　　　　　　问题2:不要多次使用it.next()方法，因为每次使用都去访问一个对象。
　　　　　　　　　　//System.out.println(((Student) it.next()).getName() + "---" + ((Student) it.next()).getAge());
　　　　　　　　　　//NoSuchElementException 不要多次使用it.next()方法。
---------------------------------------
　　(7)迭代器
　　　　A:迭代器是集合的获取元素的方式。
　　　　B:迭代器是依赖于集合而存在的。
　　　　　　因为迭代器是通过集合调用集合的方法而得到的。即必须先有集合，然后才有迭代器。
　　　　　　Collection接口的成员方法
　　　　　　　　Iterator iterator() 　　迭代器，集合的专用遍历方式。
　　　　　　Iterator接口的成员方法
　　　　　　　　boolean hasNext() 判断如果仍有元素可以迭代，则返回 true。
　　　　　　　　Object next() 　　　获取元素，并移动到下一个位置。
　　　　　　　　NoSuchElementException 没有这样的元素异常，因为你已经找到最后了。
　　　　C:迭代器的原理图解和源码浅析
　　　　　　a:迭代器为什么定义了一个接口而不是实现类？
　　　　　　　　假如把迭代器定义为一个类，这样我们就可以创建该类的对象，调用该类的方法来实现集合的遍历了。
　　　　　　　　但是，java中提供了很多的集合类，而这些集合类的数据结构是不同，所以它们的存储方法也是不同的，
　　　　　　　　进而它们的遍历方法也是不一样的，最终就没有把迭代器定义为一个类了。
　　　　　　　　　　(因为定义成一个迭代器类就是一个具体的实现了，既然是具体实现那么它们的遍历方式就是一样的了)

　　　　　　　　而无论是那种集合，都应该具备获取元素的功能，并且最好辅助以判断的功能，这样在获取前，先判断，就不容易出错。
　　　　　　　　也就是说，判断和获取功能应该是一个集合遍历所具备的，而每种集合的遍历方式又不太一样，
　　　　　　　　所以把这两个功能给提取出来，并不提供具体的实现，而这种方式叫做接口。

　　　　　　　　那么，真正的具体的实现类在哪里呢？
　　　　　　　　在真正的具体的子类中，是以内部类的方式体现的。
　　　　　　　　　　(因为在子类中要包含两个方法)
　　　　　　　　如下图所示：

　　　　
　　　　　　b:迭代器的内部类实现源码浅析

 1 -----------------------------------------------------------------------------
 2 public interface Inteator {
 3     public abstract boolean hasNext(); // 注意：默认方法前有public abstract修饰，是接口中方法的默认修饰符
 4     public abstract Object next();     // 注意：默认方法前有public abstract修饰，是接口中方法的默认修饰符
 5 }
 6 
 7 public interface Iterable {
 8     Iterator iterator(); // 没有具体实现，注意：默认方法前有public abstract修饰，是接口中方法的默认修饰符
 9 }
10 -----------------------------------------------------------------------------
11 public interface Collection extends Iterable {
12     Iterator iterator(); // 没有具体实现，注意：默认方法前有public abstract修饰，是接口中方法的默认修饰符
13 }
14 
15 public interface List extends Collection {
16     Iterator iterator(); // 没有具体实现，注意：默认方法前有public abstract修饰，是接口中方法的默认修饰符
17 }
18 -----------------------------------------------------------------------------
19 public class ArrayList implements List {
20     public Iterator iterator() { // 具体实现
21         return new Itr();
22     }
23     
24     private class Itr implements Iterator { // Itr是Iterator接口的实现类
25         public boolean hasNext() {}
26         public Object next(){} 
27     }
28 }
29 -----------------------------------------------------------------------------
30 Collection c = new ArrayList();
31 c.add("hello");
32 c.add("world");
33 c.add("java");
34 Iterator it = c.iterator();     // new Itr();
35 while(it.hasNext()) {
36     String s = (String)it.next();
37     System.out.println(s);
38 }
39 -----------------------------------------------------------------------------

迭代器的源码浅析

---------------------------------------
　　(8)Collection集合的案例(遍历方式：迭代器方式)(要求：用记事本默写)
　　　　集合的使用步骤：
　　　　　　A:创建集合对象
　　　　　　B:创建元素对象
　　　　　　C:把元素添加到集合
　　　　　　D:遍历集合
　　　　　　　　a:通过集合对象获取迭代器对象
　　　　　　　　b:通过迭代器对象的hasNext()方法判断是否有元素
　　　　　　　　c:通过迭代器对象的next()方法获取元素并移动到下一个位置

　　　　A:存储字符串并遍历

            import java.util.Collection;
            import java.util.ArrayList;
            import java.util.Iterator;

            public class CollectionDemo {
                public static void main(String[] args) {
                    // 创建集合对象
                    Collection c = new ArrayList();
                    
                    // 创建元素对象
                    String s = new String("hello");
                    // 把元素添加到结合
                    c.add(s);
                    c.add("world");
                    c.add("java");
                    
                    // 遍历集合
                    // 通过集合对象获取迭代器对象
                    Iterator it = c.iterator();
                    while (it.hasNext()) {
                        String s1 = (String) it.next();
                        System.out.println(s1);
                    }
                }
            }

---------------------------------------
　　　　B:存储自定义对象并遍历

            public class Student {
                private String name;
                private int age;

                public Student() {
                    super();
                }

                public Student(String name, int age) {
                    super();
                    this.name = name;
                    this.age = 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;
                }

            }

            import java.util.Collection;
            import java.util.ArrayList;
            import java.util.Iterator;
            
            public class StudentDemo {
                public static void main(String[] args) {
                    // 创建集合对象
                    Collection c = new ArrayList();
                    
                    // 创建学生对象
                    Student s1 = new Student("貂蝉", 25); // 含参构造
                    Student s2 = new Student("小乔", 16);
                    Student s3 = new Student("黄月英", 20);
                    Student s4 = new Student(); // 无参构造
                    s4.setName("大乔");
                    s4.setAge(26);

                    // 把学生对象添加到集合对象中
                    c.add(s1);
                    c.add(s2);
                    c.add(s3);
                    c.add(s4);
                    c.add(new Student("孙尚香", 18)); // 匿名对象
                    
                    // 遍历集合
                    Iterator it = c.iterator();
                    while (it.hasNext()) {
                        Student s = (Student) it.next();
                        System.out.println(s.getName() + "---" + s.getAge());
                    }
                }
            }

-----------------------------------------------------------------------------
3:集合(List接口)(掌握)
　　(1)List是Collection的子接口
　　　　特点：有序(存储顺序和取出顺序一致)，有索引，可以存储重复元素。
　　(2)List的特有功能(注意：默认方法前有public abstract修饰)
　　　　A:添加功能
　　　　　　void add(int index, Object element) 　　在指定位置添加元素
　　　　B:删除功能
　　　　　　Object remove(int index) 　　根据索引删除元素，返回被删除的元素
　　　　C:获取功能
　　　　　　Object get(int index) 　　获取指定位置的元素
　　　　D:列表迭代器功能
　　　　　　ListIterator listIterator() 　　 List集合特有的迭代器
　　　　E:修改功能
　　　　　　Object set(int index, Object element) 根据索引修改元素，返回被修该的元素
---------------------------------------
　　(3)List集合的特有遍历功能
　　　　A:由size()和get()结合。
　　　　B:代码演示

 1         import java.util.List;
 2         import java.util.ArrayList;
 3         import java.util.Iterator;
 4 
 5         public class ListDemo {
 6             public static void main(String[] args) {
 7                 // 创建集合对象
 8                 List list = new ArrayList();
 9                 
10                 // 创建元素对象，并添加
11                 list.add("hello");
12                 list.add("wprld");
13                 list.add("java");
14                 
15                 // 通过集合对象获取迭代器对象
16                 Iterator it = list.iterator();
17                 // 迭代器遍历集合
18                 while (it.hasNext()) {
19                     String s = (String) it.next();
20                     System.out.println(s);
21                 }
22                 
23                 // 普通for循环遍历集合
24                 for (int x = 0; x < list.size(); x++) {
25                     String s = (String) list.get(x);
26                     System.out.println(s);
27                 }
28             }
29         }

---------------------------------------
　　(4)列表迭代器的特有功能(了解)
　　　　Object previous() 　　　　获取上一个元素
　　　　boolean hasPrevious() 　判断是否有元素
　　　　注意：ListIterator可以实现逆向遍历，但是必须先正向遍历，才能逆向遍历，所以一般无意义，不使用。
　　(5)ConcurrentModificationException 并发修改异常
　　　　当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。
　　　　A:出现的现象
　　　　　　迭代器在遍历集合时，用集合去修改集合元素。
　　　　B:产生的原因
　　　　　　迭代器是依赖于集合而存在的，在判断成功后，集合中新添加了元素，集合发生了改变，而迭代器却不知道，所以就报错了，这个错叫并发修改异常。
　　　　　　其实这个问题描述的是：迭代器在遍历元素的时候，通过集合是不能修改元素的。
　　　　C:解决的方案
　　　　　　a:迭代器迭代元素，用列表迭代器(ListIterator)修改元素
　　　　　　　　元素是跟在刚才迭代的元素后面的。
　　　　　　　　注意：Iterator迭代器却没有添加功能，所以我们使用其子接口ListIterator列表迭代器。
　　　　　　b:集合遍历元素，用集合修改元素(普通for循环：size()和get())
　　　　　　　　元素是在最后添加的。(即元素添加在集合的末尾)
---------------------------------------
　　(6)常见的数据结构以及其优缺点
　　　　A:栈　　　先进后出
　　　　B:队列　　先进先出
　　　　C:数组　　查询快，增删慢
　　　　D:链表　　查询慢，增删快
　　　　E:树
　　　　F:哈希表
　　　　如下图所示：

　　　　
---------------------------------------
　　(7)List的子类特点(面试题)
　　　　ArrayList
　　　　　　底层数据结构是数组，查询快，增删慢。
　　　　　　线程不安全，效率高。
　　　　Vector
　　　　　　底层数据结构是数组，查询快，增删慢。
　　　　　　线程安全，效率低。
　　　　LinkedList
　　　　　　底层数据结构是链表，查询慢，增删快。
　　　　　　线程不安全，效率高。

　　　　List有三个儿子，我们到底使用谁呢?
　　　　　　看需求(看情况)。
　　　　分析：
　　　　　　要安全吗?
　　　　　　　　要：Vector(即使要，也不使用这个，后面有替代的)
　　　　　　　　不要：ArrayList或者LinkedList
　　　　　　查询多：ArrayList
　　　　　　增删多：LinkedList

　　　　什么都不知道，就用ArrayList。
---------------------------------------
　　(8)List集合的案例(遍历方式：迭代器和普通for循环)
　　　　A:存储字符串并遍历

　　　　　　示例代码如下：

 1 import java.util.List;
 2 import java.util.ArrayList;
 3 import java.util.Iterator;
 4 
 5 public class ListDemo {
 6     public static void main(String[] args) {
 7         // 创建集合对象
 8         List list = new ArrayList();
 9         
10         // 创建元素对象，并添加
11         list.add("hello");
12         list.add("wprld");
13         list.add("java");
14         
15         // 通过集合对象获取迭代器对象
16         Iterator it = list.iterator();
17         // 迭代器遍历集合
18         while (it.hasNext()) {
19             String s = (String) it.next();
20             System.out.println(s);
21         }
22         
23         // 普通for循环遍历集合
24         for (int x = 0; x < list.size(); x++) {
25             String s = (String) list.get(x);
26             System.out.println(s);
27         }
28     }
29 }

ListDemo.java

　　　　B:存储自定义对象并遍历

　　　　　　示例代码如下：

 1 package cn.itcast_03;
 2 
 3 public class Student {
 4     // 成员变量
 5     private String name;
 6     private int age;
 7 
 8     // 构造方法
 9     public Student() {
10         super();
11     }
12 
13     public Student(String name, int age) {
14         super();
15         this.name = name;
16         this.age = age;
17     }
18 
19     // 成员方法
20     // getXxx()/setXxx()
21     public String getName() {
22         return name;
23     }
24 
25     public void setName(String name) {
26         this.name = name;
27     }
28 
29     public int getAge() {
30         return age;
31     }
32 
33     public void setAge(int age) {
34         this.age = age;
35     }
36 }

Student.java

 1 package cn.itcast_03;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Iterator;
 5 import java.util.List;
 6 
 7 /*
 8  * 存储自定义对象并遍历，遍历方式：迭代器和普通for循环。(size()和get()结合)
 9  */
10 public class ListDemo3 {
11     public static void main(String[] args) {
12         // 创建集合对象
13         List list = new ArrayList();
14 
15         // 创建学生对象
16         Student s1 = new Student("林黛玉", 18);
17         Student s2 = new Student("刘姥姥", 88);
18         Student s3 = new Student("王熙凤", 38);
19 
20         // 把学生添加到集合中
21         list.add(s1);
22         list.add(s2);
23         list.add(s3);
24 
25         // 遍历
26         // 迭代器遍历集合
27         Iterator it = list.iterator();
28         while (it.hasNext()) {
29             Student s = (Student) it.next();
30             System.out.println(s.getName() + "---" + s.getAge());
31         }
32         System.out.println("-----------");
33 
34         // 普通for循环遍历集合
35         for (int x = 0; x < list.size(); x++) {
36             Student s = (Student) list.get(x);
37             System.out.println(s.getName() + "---" + s.getAge());
38         }
39     }
40 }

ListDemo3.java

=============================================================================

我的GitHub地址： https://github.com/heizemingjun
我的博客园地址： http://www.cnblogs.com/chenmingjun
我的蚂蚁笔记博客地址： http://blog.leanote.com/chenmingjun
Copyright ©2018 黑泽明军
【转载文章务必保留出处和署名，谢谢！】

微信关注我们

原文链接：https://yq.aliyun.com/articles/607602

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

java中迭代器的原理图解和源码浅析

a:迭代器为什么定义了一个接口而不是实现类？假如把迭代器定义为一个类，这样我们就可以创建该类的对象，调用该类的方法来实现集合的遍历了。但是，java中提供了很多的集合类，而这些集合类的数据结构是不同，所以它们的存储方法也是不同的，进而它们的遍历方法也是不一样的，最终就没有把迭代器定义为一个类了。 (因为定义成一个迭代器类就是一个具体的实现了，既然是具体实现那么它们的遍历方式就是一样的了) 而无论是那种集合，都应该具备获取元素的功能，并且最好辅助以判断的功能，这样在获取前，先判断，就不容易出错。也就是说，判断和获取功能应该是一个集合遍历所具备的，而每种集合的遍历方式又不太一样，所以把这两个功能给提取出来，并不提供具体的实现，而这种方式叫做接口。那么，真正的具体的实现类在哪里呢？在真正的具体的子类中，是以内部类的方式体现的。 (因为在子类中要包含两个方法) 如下图所示： b:迭代器的内部类实现源码浅析 ----------------------------------------------------------------------------- public int...

2018-03-19

567

java编译器认为该程序存在安全隐患(没有学习泛型前)

注意：StudentDemo.java使用了未经检查或不安全的操作。注意：要了解详细信息，请使用 -Xlint:unchecked重新编译。 java编译器认为该程序存在安全隐患温馨提示：这不是编译失败，所以先不用理会，等学了泛型你就知道了。如下图所示：我的GitHub地址： https://github.com/heizemingjun 我的博客园地址： http://www.cnblogs.com/chenmingjun 我的蚂蚁笔记博客地址： http://blog.leanote.com/chenmingjun Copyright ©2018 黑泽明军【转载文章务必保留出处和署名，谢谢！】

2018-03-19

616

发表评论

资源下载

更多资源

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。

WebStorm

WebStorm 是jetbrains公司旗下一款JavaScript 开发工具。目前已经被广大中国JS开发者誉为“Web前端开发神器”、“最强大的HTML5编辑器”、“最智能的JavaScript IDE”等。与IntelliJ IDEA同源，继承了IntelliJ IDEA强大的JS部分的功能。