1 1:对象数组(掌握)
2 (1)数组既可以存储基本数据类型，也可以存储引用类型。它存储引用类型的时候的数组就叫对象数组。
3 (2)案例：
4 用数组存储5个学生对象，并遍历数组。
5
6 2:集合(Collection)(掌握)
7 (1)集合的由来?
8 我们学习的是Java -- 面向对象 -- 操作很多对象 -- 存储 -- 容器(数组和StringBuffer) -- 数组
9 而数组的长度固定，所以不适合做变化的需求，Java就提供了集合供我们使用。
10 (2)集合和数组的区别?
11 A:长度区别
12 数组固定
13 集合可变
14 B:内容区别
15 数组可以是基本类型，也可以是引用类型
16 集合只能是引用类型
17 C:元素内容
18 数组只能存储同一种类型
19 集合可以存储不同类型(其实集合一般存储的也是同一种类型)
20 (3)集合的继承体系结构?
21 由于需求不同，Java就提供了不同的集合类。这多个集合类的数据结构不同，但是它们都是要提供存储和遍历功能的，
22 我们把它们的共性不断的向上提取，最终就形成了集合的继承体系结构图。
23
24 Collection
25 |--List
26 |--ArrayList
27 |--Vector
28 |--LinkedList
29 |--Set
30 |--HashSet
31 |--TreeSet
32 (4)Collection的功能概述(自己补齐)
33 A:添加功能
34 B:删除功能
35 C:判断功能
36 D:获取功能
37 E:长度功能
38 F:交集(了解)
39 G:把集合转数组(了解)
40 (5)Collection集合的遍历
41 A:把集合转数组(了解)
42 B:迭代器(集合专用方式)
43 (6)迭代器
44 A:是集合的获取元素的方式。
45 B:是依赖于集合而存在的。
46 C:迭代器的原理和源码。
47 a:为什么定义为了一个接口而不是实现类?
48 b:看了看迭代器的内部类实现。
49 (7)Collection集合的案例(遍历方式 迭代器)
50 集合的操作步骤：
51 A:创建集合对象
52 B:创建元素对象
53 C:把元素添加到集合
54 D:遍历集合
55
56 A:存储字符串并遍历
57 import java.util.Collection;
58 import java.util.ArrayList;
59 import java.util.Iterator;
60
61 public class CollectionDemo {
62 public static void main(String[] args) {
63 //创建集合对象
64 Collection c = new ArrayList();
65
66 //创建并添加元素
67 c.add("hello");
68 c.add("world");
69 c.add("java");
70
71 //遍历集合
72 Iterator it = c.iterator();
73 while(it.hasNext()) {
74 String s =(String) it.next();
75 System.out.println(s);
76 }
77 }
78 }
79
80 B:存储自定义对象并遍历
81 public class Student {
82 private String name;
83 private int age;
84
85 public Student(){}
86
87 public Student(String name,int age) {
88 this.name = name;
89 this.age = age;
90 }
91
92 //getXxx()/setXxx()
93 }
94
95 import java.util.Collection;
96 import java.util.ArrayList;
97 import java.util.Iterator;
98
99 public class StudentDemo {
100 public static void main(String[] args) {
101 //创建集合对象
102 Collection c = new ArrayList();
103
104 //创建学生对象
105 Student s1 = new Student("林青霞",27);
106 Student s2 = new Student("风清扬",30);
107 Student s3 = new Student("刘意",30);
108 Student s4 = new Student("武鑫",25);
109 Student s5 = new Student("刘晓曲",16);
110
111 //添加元素
112 c.add(s1);
113 c.add(s2);
114 c.add(s3);
115 c.add(s4);
116 c.add(s5);
117
118 //遍历集合
119 Iterator it = c.iterator();
120 while(it.hasNext()) {
121 Student s = (Student)it.next();
122 System.out.println(s.getName()+"---"+s.getAge());
123 }
124 }
125 }
126
127 3:集合(List)(掌握)
128 (1)List是Collection的子接口
129 特点：有序(存储顺序和取出顺序一致)，可重复。
130 (2)List的特有功能：(自己补齐)
131 A:添加功能
132 B:删除功能
133 C:获取功能
134 D:迭代器功能
135 E:修改功能
136 (3)List集合的特有遍历功能
137 A:由size()和get()结合。
138 B:代码演示
139 //创建集合对象
140 List list = new ArrayList();
141
142 //创建并添加元素
143 list.add("hello");
144 list.add("world");
145 list.add("java");
146
147 //遍历集合
148 Iterator it = list.iterator();
149 while(it.hasNext()) {
150 String s =(String) it.next();
151 System.out.println(s);
152 }
153 System.out.println("----------");
154
155 for(int x=0; x<list.size(); x++) {
156 String s =(String) list.get(x);
157 System.out.println(s);
158 }
159 (4)列表迭代器的特有功能；(了解)
160 可以逆向遍历，但是要先正向遍历，所以无意义，基本不使用。
161 (5)并发修改异常
162 A:出现的现象
163 迭代器遍历集合，集合修改集合元素
164 B:原因
165 迭代器是依赖于集合的，而集合的改变迭代器并不知道。
166 C:解决方案
167 a:迭代器遍历，迭代器修改(ListIterator)
168 元素添加在刚才迭代的位置
169 b:集合遍历，集合修改(size()和get())
170 元素添加在集合的末尾
171 (6)常见数据结构
172 A:栈 先进后出
173 B:队列 先进先出
174 C:数组 查询快，增删慢
175 D:链表 查询慢，增删快
176 (7)List的子类特点(面试题)
177 ArrayList
178 底层数据结构是数组，查询快，增删慢。
179 线程不安全，效率高。
180 Vector
181 底层数据结构是数组，查询快，增删慢。
182 线程安全，效率低。
183 LinkedList
184 底层数据结构是链表，查询慢，增删快。
185 线程不安全，效率高。
186
187 到底使用谁呢?看需求?
188 分析：
189 要安全吗?
190 要：Vector(即使要，也不使用这个，后面再说)
191 不要：ArrayList或者LinkedList
192 查询多；ArrayList
193 增删多：LinkedList
194
195 什么都不知道，就用ArrayList。
196 (8)List集合的案例(遍历方式 迭代器和普通for)
197 A:存储字符串并遍历
198 B:存储自定义对象并遍历
1 package hello;
2
3 import java.util.ArrayList;
4 import java.util.Arrays;
5 import java.util.List;
6 import java.util.Scanner;
7
8 public class Test02{
9 public static void main(String[] args) {
10 //键盘输入，以0结束，输出最大值
11 Scanner sc=new Scanner(System.in);
12 List<Integer> list=new ArrayList<Integer>();
13 while(true){
14 int num=sc.nextInt();
15 if(num!=0){
16 list.add(num);
17 }else{
18 break;
19 }
20 }
21 Integer[] i=new Integer[list.size()];
22 list.toArray(i);
23 Arrays.sort(i);
24 int max=i[i.length-1];
25
26
27 }
28 }
////////////////////////////
1 package hello;
2
3 import java.util.TreeSet;
4
5
6
7 public class Test02{
8 public static void main(String[] args) {
9 TreeSet<Person> ts=new TreeSet<Person>();
10
11 Person p1=new Person("hello",22);
12 Person p2=new Person("world",21);
13 Person p3=new Person("java",12);
14 Person p4=new Person("boy",32);
15 Person p6=new Person("cguang",25);
16 Person p5=new Person("aguang",25);
17
18 ts.add(p1);
19 ts.add(p2);
20 ts.add(p3);
21 ts.add(p4);
22 ts.add(p5);
23 ts.add(p6);
24
25 for(Person pp:ts){
26 System.out.println(pp);
27 }
28 }
29 }
1 package hello;
2
3 public class Person implements Comparable<Person>{
4 private String name;
5 private int age;
6 public Person() {
7 super();
8 // TODO Auto-generated constructor stub
9 }
10 public Person(String name, int age) {
11 super();
12 this.name = name;
13 this.age = age;
14 }
15 public String getName() {
16 return name;
17 }
18 public void setName(String name) {
19 this.name = name;
20 }
21 public int getAge() {
22 return age;
23 }
24 public void setAge(int age) {
25 this.age = age;
26 }
27 @Override
28 public String toString() {
29 return "Person [name=" + name + ", age=" + age + "]";
30 }
31 @Override
32 public int compareTo(Person o) {
33 // TODO Auto-generated method stub
34 int num=this.age-o.age;
35 int num2=num==0?this.name.compareTo(o.name):num;
36 return num2;
37 }
38
39 }
1 package hello;
2
3 import java.util.HashSet;
4 import java.util.Random;
5 import java.util.TreeSet;
6
7
8
9 public class Test02{
10 public static void main(String[] args) {
11 Random r=new Random();
12 HashSet<Integer> hs=new HashSet<Integer>();
13 while(hs.size()<10){
14 int num=r.nextInt(20)+1;
15 hs.add(num);
16 }
17 for(Integer i:hs){
18 System.out.println(i);
19 }
20 }
21 }
1 package hello;
2
3 import java.util.Collection;
4 import java.util.Comparator;
5 import java.util.HashMap;
6 import java.util.HashSet;
7 import java.util.Map;
8 import java.util.Random;
9 import java.util.Scanner;
10 import java.util.Set;
11 import java.util.TreeMap;
12 import java.util.TreeSet;
13
14 public class Test02 {
15
16 public static void main(String[] args) {
17 String s="asdfasdfasdfas";
18 TreeMap<Character,Integer> map=new TreeMap<Character,Integer>();
19
20 char[] chs=s.toCharArray();
21 for(int i=0;i<chs.length;i++){
22 Integer num=map.get(chs[i]);
23 if(num==null){
24 map.put(chs[i],1);
25 }else{
26 num++;
27 map.put(chs[i],num);
28 }
29
30 }
31 StringBuilder s1=new StringBuilder();
32 Set<Character> set=map.keySet();
33 for(Character key:set){
34 Integer value=map.get(key);
35 s1.append(key).append("(").append(value).append(")");
36 }
37 String res=s1.toString();
38 System.out.println(res);
39 }
40 }
