1、集合
存储对象的方式
1.1、区别于数组
（1）集合长度可变，数组长度固定
（2）集合只能存对象，数组存储基本数据类型
同：存的都是地址，
1.2、CPUD
1.3、迭代器（内部类比作抓娃娃机，迭代过程比作爪子,爪子各不相同，功能有共性，都在机器内部）
集合取出元素的方式
1 import java.util.*;
2 class CollectionDemo
3 {
4 public static void main(String[] args)
5 {
6
7 method_get();
8
9
10 }
11 public static void method_get()
12 {
13 ArrayList al=new ArrayList();
14 al.add("java1");
15 al.add("java2");
16 al.add("java3");
17 al.add("java4");
18
19 /*
20 Iterator it = al.iterator();//获取迭代器,用于取出集合中的元素 接口不能创建对象，通过集合的iterator方法，返回迭代器。
21 while(it.hasNext())
22 {
23 sop(it.next);
24 }
25 */
26 for(Iterator it=al.iterator();it.hasNext();)
27 {
28 sop(it.next());
29 }
30
31 }
32 public static void method_2()
33 {
34 ArrayList al1=new ArrayList();
35 al1.add("java1");
36 al1.add("java2");
37 al1.add("java3");
38 al1.add("java4");
39
40 ArrayList al2=new ArrayList();
41 al2.add("java1");
42 al2.add("java2");
43 al2.add("java5");
44 al2.add("java6");
45
46 //al1.retainAll(al2);//取交集，al1中只保留和al2中相同的元素
47 al1.removeAll(al2);//去掉相同，留不同
48
49 sop("al1:"+al1);
50 sop("al2:"+al2);
51 }
52 public static void base_method()
53 {
54 //创建一个集合容器，使用Collection接口的子类，ArrayList
55 ArrayList al=new ArrayList();
56
57 //1、添加元素
58 al.add("java1");//add(Object obj)
59 al.add("java2");
60 al.add("java3");
61 al.add("java4");
62
63 //打印原集合
64 sop("原集合"+al);
65 //3、删除元素
66 //al.remove("java2");
67 //al.clear();清空
68
69 //4、判断元素
70 sop("java03是否存在："+al.contains("java03"));
71 sop("集合是否为空？"+al.isEmpty());
72 //2、获取个数，集合长度
73 sop("size:"+al.size());
74 //打印改变后的集合
75 sop(al);
76 }
77 public static void sop(Object obj)
78 {
79 System.out.println(obj);
80 }
81 }
Collection
|--List:元素有序，可以重复，因为该集合体有索引（下标）
|--ArrayList:底层的数据结构是数组结构，特点：查询速度快，增删慢，线程不同步
|--LinkedList:底层使用的是链表数据结构，特点：增删速度快，查询慢
|--Vector:底层是数组数据结构，线程同步，被ArrayList替代
|--Set:元素无序，元素不可以重复。
1.4、List
特有方法，凡是可以操作角标的方法都是该体系特有的方法
增
add(index,element);
addAll(index, Collection);
删
remove(index);
改
set(index,element)
查
get(index);
subList(from,to);
listIterator();
1.4.1、ListIterator
List集合特有迭代器 ListIterator是Iterator的子接口
在迭代时，不可通过集合对象的方法，操作集合中的元素，
因为会发生并发修改异常
ConcurrentModificationException异常
Iterator: 判断，取出，删除
ListIterator: 添加，修改
1.4.2、枚举
1 package learn;
2 import java.util.*;
3 /*
4 * 枚举就是Vector特有的取出方式
5 * 发现枚举和迭代器很像，因为枚举的名称以及方法的名称都过长
6 * 所以被迭代器取代了
7 * IO中会用到
8 * */
9 public class VectorDemo {
10 public static void main(String[] args) {
11 Vector v=new Vector();
12 v.add("java01");
13 v.add("java02");
14 v.add("java03");
15 v.add("java04");
16
17 Enumeration en=v.elements();
18
19 while(en.hasMoreElements())
20 {
21 System.out.println(en.nextElement());
22 }
23
24 }
25 }
LinkedList练习
1 package learn;
2
3 import java.util.LinkedList;
4
5 /*
6 * 使用LinkedList模拟一个堆栈或者队列数据结构
7 * 堆栈：先进后出，杯子
8 * 队列：先进先出， first in first out FIFO,水管
9 * */
10 class Duilie
11 {
12 private LinkedList link;
13 Duilie()
14 {
15 link = new LinkedList();
16 }
17 public void myAdd(Object obj)
18 {
19 link.addFirst(obj);
20 }
21 public Object myGet()
22 {
23 return link.removeLast();
24 }
25 public boolean isNull()
26 {
27 return link.isEmpty();
28 }
29
30
31 }
32 public class LinkedListTest {
33 public static void main(String[] args) {
34 Duilie dl=new Duilie();
35 dl.myAdd("java01");
36 dl.myAdd("java02");
37 dl.myAdd("java03");
38 dl.myAdd("java04");
39 while(!dl.isNull())
40 {
41 System.out.println(dl.myGet());
42 }
43 }
44 }
去除ArrayList集合中的重复元素
1 package learn;
2
3 import java.util.ArrayList;
4 import java.util.Iterator;
5
6 /*
7 * 去除ArrayList集合中的重复元素
8 * */
9 public class ArrayListTest {
10 public static void main(String[] args) {
11 ArrayList al=new ArrayList();
12 al.add("java01");
13 al.add("java02");
14 al.add("java01");
15 al.add("java02");
16 al.add("java01");
17 // al.add("java03");
18 /*
19 * 在迭代器循环中next调用一次，就要hasNext判断一次
20 Iterator it=al.iterator();
21 while(it.hasNext())
22 {
23 sop(it.next()+"..."+it.next());
24 }
25 */
26 sop(al);
27 al=singleElement(al);
28 sop(al);
29
30 }
31 public static void sop(Object obj)
32 {
33 System.out.println(obj);
34
35 }
36 public static ArrayList singleElement(ArrayList al)
37 {
38 ArrayList newal=new ArrayList();
39 Iterator it=al.iterator(); //根据传递进来的arraylist创建迭代器，存放如全新的newal
40 while(it.hasNext())
41 {
42 Object obj=it.next();
43 if(!newal.contains(obj))
44 {
45 newal.add(obj);
46 }
47
48 }
49 return newal;
50 }
51 }
1 package learn;
2
3 /*
4 *将自定义对象作为元素存到ArrayList集合中，并去除重复元素
5 *比如:存入对象，同姓名，同年龄，视为同一个人，为重复元素
6 * */
7 import java.util.ArrayList;
8 import java.util.Iterator;
9
10 class Person{
11 private String name;
12 private int age;
13 Person(String name,int age)
14 {
15 this.name=name;
16 this.age=age;
17 }
18 //Person的字符串方法
19 public boolean equals(Object obj)
20 {
21
22 if(!(obj instanceof Person))
23 return false;
24 Person p =(Person)obj;
25 System.out.println(this.name+"..."+p.name);
26 //字符串的equals方法
27 return this.name.equals(p.name)&& this.age==p.age;
28
29 }
30 public String getName()
31 {
32 return name;
33 }
34 public int getAge()
35 {
36 return age;
37 }
38 }
39
40
41 public class ArrayListTest2 {
42 public static void sop(Object obj)
43 {
44 System.out.println(obj);
45 }
46 public static void main(String[] args) {
47
48
49 ArrayList al=new ArrayList();
50 al.add(new Person("lisi01",30));//al.add(Object obj);//Object obj=new Person("lisi01",30);
51 al.add(new Person("lisi02",32));
52 al.add(new Person("lisi02",32));
53 al.add(new Person("lisi03",33));
54 al.add(new Person("lisi04",35));
55 al.add(new Person("lisi04",35));
56
57 al=singleElement(al);
58 sop("remover 03:"+al.remove(new Person("lisi03",33)));
59 Iterator it=al.iterator();
60 while(it.hasNext())
61 {
62 // Object obj=it.next();
63 // Person p=(Person)obj;
64 Person p=(Person)it.next();
65 sop(p.getName()+"..."+p.getAge());
66 }
67
68 }
69 public static ArrayList singleElement(ArrayList al)
70 {
71 //定义一个临时容器
72 ArrayList newal=new ArrayList();
73 Iterator it=al.iterator(); //根据传递进来的arraylist创建迭代器，存放如全新的newal
74 while(it.hasNext())
75 {
76 Object obj=it.next();
77 if(!newal.contains(obj))//contains中含有equals
78 {
79 newal.add(obj);
80 }
81
82 }
83 return newal;
84 }
85 }
1.5、Set
1.5.1、HashSet
1 package learn;
2
3 import java.util.HashSet;
4 import java.util.Iterator;
5
6 //|--Set：无序(存入、取出顺序不一致)，元素不可重复
7 // |--HashSet：底层数据结构是哈希表
8 // |--HashSet是如何保证元素唯一性
9 //通过元素的hashCode和equals
10 //若元素HashCode值相同，才会判断equals是否为true
11 //不同则不调
12 //注意，对于判断元素是否存在，以及删除操作，依赖的方法是，元素的hashcode（先）和equals方法
13 //set集合的功能时和Collection一致的
14 public class HashSetDemo {
15 public static void sop(Object obj){
16 System.out.println(obj);
17 }
18 public static void main(String[] args) {
19 //按照地址存进去的
20 HashSet hs = new HashSet();
21
22 //添加失败
23 sop(hs.add("java01"));
24 sop(hs.add("java01"));
25 hs.add("java01");
26 hs.add("java01");
27 hs.add("java02");
28 hs.add("java03");
29 hs.add("java04");
30 Iterator it=hs.iterator();
31 while(it.hasNext())
32 {
33 sop(it.next());
34 }
35 }
36 }
1 package Test;
2 import java.util.HashSet;
3 import java.util.Iterator;
4 /*
5 * 往HashSet集合中存入自定义对象，姓名年龄相同视为重复对象
6 * */
7 class Person{
8 private String name;
9 private int age;
10 Person(String name,int age)
11 {
12 this.name=name;
13 this.age=age;
14 }
15 public int hashCode()
16 {
17 System.out.println(this.name+"...hashCode");
18 return name.hashCode()+age*39;//防止相加后的哈希值相同
19 }
20 //Person的字符串方法
21 public boolean equals(Object obj)
22 {
23
24 if(!(obj instanceof Person))
25 return false;
26 Person p =(Person)obj;
27 System.out.println(this.name+"...equals..."+p.name);
28 //字符串的equals方法
29 return this.name.equals(p.name)&& this.age==p.age;
30
31 }
32 public String getName()
33 {
34 return name;
35 }
36 public int getAge()
37 {
38 return age;
39 }
40 }
41
42 public class HashSetTest {
43 public static void sop(Object obj)
44 {
45 System.out.println(obj);
46 }
47 public static void main(String[] args) {
48 HashSet hs=new HashSet();
49 hs.add(new Person("a1",11));
50 hs.add(new Person("a2",12));
51 hs.add(new Person("a3",13));
52 hs.add(new Person("a2",12));
53 // hs.add(new Person("a4",14));
54 Iterator it=hs.iterator();
55 while(it.hasNext())
56 {
57 Person p=(Person)it.next();
58 sop(p.getName()+"..."+p.getAge());
59 }
60 }
61 }
时间： 2024-10-15 12:58:22