7. 集合（容器）
1. 容器的作用和概览
（1）数组总结回顾
a)作用：是一种容器，可以在其中放置对象或基本类型数据。从而，实现使用数组管理一组对象。
b)优势：是一种简单的线性序列，可以快速的访问数组元素，效率高。如果从效率和类型检查的角度讲，数组是最好的。
c)劣势：不灵活：容量事先定义好，不能随着需求的变化而扩容。
（2）数组远远不能满足我们的需求。我们需要一种灵活的，容量可以随时扩充的容器来装载我们的对象。这就是我们今天要学习的容器类，或者叫集合框架。
容器中的接口层次结构
一、集合概述
Java是一种面向对象语言，如果我们要针对多个对象进行操作，就必须对多个对象进行存储。而数组长度固定，不能满足变化的要求。所以，java提供了集合。
特点：
1.长度可以发生改变 2.只能存储对象 3.可以存储多种类型对象
* 数组和集合的区别?
* A:长度区别
* 数组的长度固定
* 集合长度0可变
* B:内容不同
* 数组存储的是同一种类型的元素
* 而集合可以存储不同类型的元素
* C:元素的数据类型问题
* 数组可以存储基本数据类型，也可以存储引用数据类型
* 集合只能存储引用类型
二、集合体系
集合作为一个容器，可以存储多个元素，但是由于数据结构的不同，java提供了多种集合类。将集合类中共性的功能，不断向上抽取，最终形成了集合体系结构。
数据结构：数据存储的方式
Java中集合类的关系图
2. Collection集合
1、Collection
Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行，于是衍生出两个子类接口List和Set。
|
|
|
|
2、Collection接口
（1）Collection 表示一组对象，它是集中，收集的意思，就是把一些数据收集起来
（2）Collection接口的两个子接口：
Set中的数据没有顺序，不可重复。(set两无产品)
List中的数据有顺序，可重复。（list二有产品）
3、为什么出现集合类?
面向对象都是以对象的形式的体现，所以为了方便对多个对象的操作，就对对象进行了存储，集合就是存储对象最常用的一种方式
4、如果并不知道程序运行时会需要多少对象，或者需要更复杂方式存储对象——可以使用Java集合框架
Collection接口，是所有集合框架的父接口（除了map）
Collection存储的是不唯一，无序的数据，主要的子接口有两个，list，set
集合框架中只能存储引用类型的数据 Collection 中可以存放无序，不唯一的数据
5、普通for循环不能遍历
(1)、加强for循环
for (Object object : coll) {
System.out.println(object);
}
(2)、使用迭代器
Iterator it = coll.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
(3)、老外的写法(建议使用此方法，省内存)
for (Iterator it2 = coll.iterator(); it2.hasNext();) {
System.out.println(it2.next());
}
|
|
* Collection:是集合的顶层接口，它的子体系有重复的，有唯一的，有有序的，有无序的。
*
* Collection的功能概述：
* 1：添加功能
* boolean add(Object obj):添加一个元素
* boolean addAll(Collection c):添加一个集合的元素
* 2:删除功能
* void clear():移除所有元素
* boolean remove(Object o):移除一个元素
* boolean removeAll(Collection c):移除一个集合的元素(是一个还是所有)
* 3:判断功能
* boolean contains(Object o)：判断集合中是否包含指定的元素
* boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(是一个还是所有)
* boolean isEmpty()：判断集合是否为空
* 4:获取功能
* Iterator<E> iterator()(重点)
* 5:长度功能
* int size():元素的个数
* 面试题：数组有没有length()方法呢?字符串有没有length()方法呢?集合有没有length()方法呢?
数组是length，字符串是length(),集合没有length(),是size()
* 6:交集功能
* boolean retainAll(Collection c):两个集合都有的元素?思考元素去哪了，返回的boolean又是什么意思呢?
* 7：把集合转换为数组
* Object[] toArray()
*/
public class CollectionDemo {
public static void main(String[] args) {
// 创建集合对象
// Collection c = new Collection(); //错误，因为接口不能实例化
Collection c = new ArrayList();
// boolean add(Object obj):添加一个元素
c.add("hello");
c.add("world");
c.add("java");
// void clear():移除所有元素
// c.clear();
// boolean remove(Object o):移除一个元素
// System.out.println("remove:" + c.remove("hello"));
// System.out.println("remove:" + c.remove("javaee"));
// boolean contains(Object o)：判断集合中是否包含指定的元素
// System.out.println("contains:"+c.contains("hello"));
// System.out.println("contains:"+c.contains("android"));
// boolean isEmpty()：判断集合是否为空
// System.out.println("isEmpty:"+c.isEmpty());
//int size():元素的个数
System.out.println("size:"+c.size());
System.out.println("c:" + c);
}
}
|
|
/*
* boolean addAll(Collection c):添加一个集合的元素
* boolean removeAll(Collection c):移除一个集合的元素(是一个还是所有)
* boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(是一个还是所有)
* boolean retainAll(Collection c):两个集合都有的元素?思考元素去哪了，返回的boolean又是什么意思呢?
*/
public class CollectionDemo2 {
public static void main(String[] args) {
// 创建集合1
Collection c1 = new ArrayList();
c1.add("abc1");
c1.add("abc2");
c1.add("abc3");
c1.add("abc4");
// 创建集合2
Collection c2 = new ArrayList();
// c2.add("abc1");
// c2.add("abc2");
// c2.add("abc3");
// c2.add("abc4");
c2.add("abc5");
c2.add("abc6");
c2.add("abc7");
// boolean addAll(Collection c):添加一个集合的元素
// System.out.println("addAll:" + c1.addAll(c2));
//boolean removeAll(Collection c):移除一个集合的元素(是一个还是所有)
//只要有一个元素被移除了，就返回true。
//System.out.println("removeAll:"+c1.removeAll(c2));
//boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(是一个还是所有)
//只有包含所有的元素，才叫包含
// System.out.println("containsAll:"+c1.containsAll(c2));
//boolean retainAll(Collection c):两个集合都有的元素?思考元素去哪了，返回的boolean又是什么意思呢?
//假设有两个集合A，B。
//A对B做交集，最终的结果保存在A中，B不变。
//返回值表示的是A是否发生过改变。
System.out.println("retainAll:"+c1.retainAll(c2));
System.out.println("c1:" + c1);
System.out.println("c2:" + c2);
}
}
|
|
/*
* 集合的遍历。其实就是依次获取集合中的每一个元素。
* Object[] toArray():把集合转成数组，可以实现集合的遍历
*/
public class CollectionDemo3 {
public static void main(String[] args) {
// 创建集合对象
Collection c = new ArrayList();
// 添加元素
c.add("hello"); // Object obj = "hello"; 向上转型
c.add("world");
c.add("java");
// 遍历
// Object[] toArray():把集合转成数组，可以实现集合的遍历
Object[] objs = c.toArray();
for (int x = 0; x < objs.length; x++) {
// System.out.println(objs[x]);
// 我知道元素是字符串，我在获取到元素的的同时，还想知道元素的长度。
// System.out.println(objs[x] + "---" + objs[x].length());
// 上面的实现不了，原因是Object中没有length()方法
// 我们要想使用字符串的方法，就必须把元素还原成字符串
// 向下转型
String s = (String) objs[x];
System.out.println(s + "---" + s.length());
}
}
}
|
|
/*
* 练习：用集合存储5个学生对象，并把学生对象进行遍历。
*
* 分析：
* A:创建学生类
* B:创建集合对象
* C:创建学生对象
* D:把学生添加到集合
* E:把集合转成数组
* F:遍历数组
*/
public class StudentDemo {
public static void main(String[] args) {
// 创建集合对象
Collection c = new ArrayList();
// 创建学生对象
Student s1 = new Student("林青霞", 27);
Student s2 = new Student("风清扬", 30);
Student s3 = new Student("令狐冲", 33);
Student s4 = new Student("武鑫", 25);
Student s5 = new Student("刘晓曲", 22);
// 把学生添加到集合
c.add(s1);
c.add(s2);
c.add(s3);
c.add(s4);
c.add(s5);
// 把集合转成数组
Object[] objs = c.toArray();
// 遍历数组
for (int x = 0; x < objs.length; x++) {
// System.out.println(objs[x]);
Student s = (Student) objs[x];
System.out.println(s.getName() + "---" + s.getAge());
}
}
}
|
|
/*
* Iterator iterator():迭代器，集合的专用遍历方式
* Object next():获取元素,并移动到下一个位置。(方法起那么第一英文是返回类型)
* NoSuchElementException：没有这样的元素，因为你已经找到最后了。
* boolean hasNext():如果仍有元素可以迭代，则返回 true。（
*/
public class IteratorDemo {
public static void main(String[] args) {
// 创建集合对象
Collection c = new ArrayList();
// 创建并添加元素
c.add("hello");
c.add("world");
c.add("java");
// Iterator iterator():迭代器，集合的专用遍历方式
Iterator it = c.iterator(); // 实际返回的肯定是子类对象，这里是多态
// Object obj = it.next();
// System.out.println(obj);
// System.out.println(it.next());
// System.out.println(it.next());
// System.out.println(it.next());
// System.out.println(it.next());
// 最后一个不应该写，所以，我们应该在每次获取前，如果有一个判断就好了
// 判断是否有下一个元素，有就获取，没有就不搭理它
// if (it.hasNext()) {
// System.out.println(it.next());
// }
// if (it.hasNext()) {
// System.out.println(it.next());
// }
// if (it.hasNext()) {
// System.out.println(it.next());
// }
// 最终版代码
while (it.hasNext()) {
// System.out.println(it.next());
String s = (String) it.next();
System.out.println(s);
}
}
}
|
|
/*
* 问题1:能用while循环写这个程序，我能不能用for循环呢?
* 问题2:不要多次使用it.next()方法，因为每次使用都是访问一个对象。
*/
public class IteratorTest2 {
public static void main(String[] args) {
// 创建集合对象
Collection c = new ArrayList();
// 创建学生对象
Student s1 = new Student("林青霞", 27);
Student s2 = new Student("风清扬", 30);
Student s3 = new Student("令狐冲", 33);
Student s4 = new Student("武鑫", 25);
Student s5 = new Student("刘晓曲", 22);
// 把学生添加到集合中
c.add(s1);
c.add(s2);
c.add(s3);
c.add(s4);
c.add(s5);
// 遍历
Iterator it = c.iterator();
while (it.hasNext()) {
Student s = (Student) it.next();
System.out.println(s.getName() + "---" + s.getAge());
// NoSuchElementException 不要多次使用it.next()方法
// System.out.println(((Student) it.next()).getName() + "---"
// + ((Student) it.next()).getAge());
}
// System.out.println("----------------------------------");
// for循环改写
// for(Iterator it = c.iterator();it.hasNext();){
// Student s = (Student) it.next();
// System.out.println(s.getName() + "---" + s.getAge());
// }
}
}
|
|
/*
* 需求：存储字符串并遍历。
* 分析：
* A:创建集合对象
* B:创建字符串对象
* C:把字符串对象添加到集合中
* D:遍历集合
*/
public class CollectionTest {
public static void main(String[] args) {
// 创建集合对象
Collection c = new ArrayList();
// 创建字符串对象
// 把字符串对象添加到集合中
c.add("林青霞");
c.add("风清扬");
c.add("刘意");
c.add("武鑫");
c.add("刘晓曲");
// 遍历集合
// 通过集合对象获取迭代器对象
Iterator it = c.iterator();
// 通过迭代器对象的hasNext()方法判断有没有元素
while (it.hasNext()) {
// 通过迭代器对象的next()方法获取元素
String s = (String) it.next();
System.out.println(s);
}
}
}
|
|
3. List集合
1、List接口
2、List:(面试题List的子类特点)
ArrayList:
底层数据结构是数组，查询快，增删慢。因为数组结构存储的空间是连续的。
线程不安全，效率高。
Vector:
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
LinkedList:
底层数据结构是链表，查询慢，增删快。因为链表结构存储的空间是不连续的。
线程不安全，效率高。
List有三个儿子，我们到底使用谁呢?
要安全吗?
要：Vector(即使要安全，也不用这个了，后面有替代的)
不要：ArrayList或者LinkedList
查询多：ArrayList
增删多：LinkedList
如果你什么都不懂，就用ArrayList。
4、跟索引的有关操作都是list的操作
5、arrayList跟linkedList的区别
（1）底层存储结构不同
（2）arraylist查询快，但是删除和插入元素慢，linkedlist相反
6、arrayList和vector的区别
（1）扩容长度不同，arraylist是1.5倍，vector是2倍
（2）arraylist是线程不安全的，效率高，vector相反
7、Iterator接口，使用迭代器遍历集合元素
8、ArrayList实现了长度可变的数组，在内存中分配连续的空间。
–优点：遍历元素和随机访问元素的效率比较高
–缺点：添加和删除需要大量移动元素效率低，按照内容查询效率低
9、LinkedList采用链表存储方式。
–优点：插入、删除元素时效率比较高
–缺点：遍历和随机访问元素效率低下
10、List接口特有的方法
|
|
/*
* List集合的特有功能：
* A:添加功能
* void add(int index,Object element):在指定位置添加元素
* B:获取功能
* Object get(int index):获取指定位置的元素
* C:列表迭代器
* ListIterator listIterator()：List集合特有的迭代器
* D:删除功能
* Object remove(int index)：根据索引删除元素,返回被删除的元素
* E:修改功能
* Object set(int index,Object element):根据索引修改元素，返回被修饰的元素
*/
public class ListDemo {
public static void main(String[] args) {
// 创建集合对象
List list = new ArrayList();
// 添加元素
list.add("hello");
list.add("world");
list.add("java");
// void add(int index,Object element):在指定位置添加元素
// list.add(1, "android");//没有问题
// IndexOutOfBoundsException 数组下标越界
// list.add(11, "javaee");//有问题
// list.add(3, "javaee"); //没有问题
// list.add(4, "javaee"); //有问题
// Object get(int index):获取指定位置的元素
// System.out.println("get:" + list.get(1));
// IndexOutOfBoundsException
// System.out.println("get:" + list.get(11));
// Object remove(int index)：根据索引删除元素,返回被删除的元素
// System.out.println("remove:" + list.remove(1));
// IndexOutOfBoundsException
// System.out.println("remove:" + list.remove(11));
// Object set(int index,Object element):根据索引修改元素，返回被修饰的元素
System.out.println("set:" + list.set(1, "javaee"));
System.out.println("list:" + list);
}
}
|
|
/*
* List集合的特有遍历功能：
* size()和get()方法结合使用
*/
public class ListDemo2 {
public static void main(String[] args) {
// 创建集合对象
List list = new ArrayList();
// 添加元素
list.add("hello");
list.add("world");
list.add("java");
// ：size()和get()
for (int i = 0; i < list.size(); i++) {
// System.out.println(list.get(x));
String s = (String) list.get(i);
System.out.println(s);
}
}
}
|
|
/*
* 存储自定义对象并遍历,用普通for循环。(size()和get()结合)
*/
public class ListDemo3 {
public static void main(String[] args) {
// 创建集合对象
List list = new ArrayList();
// 创建学生对象
Student s1 = new Student("林黛玉", 18);
Student s2 = new Student("刘姥姥", 88);
Student s3 = new Student("王熙凤", 38);
// 把学生添加到集合中
list.add(s1);
list.add(s2);
list.add(s3);
// 遍历
// 迭代器遍历
Iterator it = list.iterator();
while (it.hasNext()) {
Student s = (Student) it.next();
System.out.println(s.getName() + "---" + s.getAge());
}
System.out.println("--------");
// 普通for循环
for (int x = 0; x < list.size(); x++) {
Student s = (Student) list.get(x);
System.out.println(s.getName() + "---" + s.getAge());
}
}
}
|
|
/*
* 列表迭代器：
* ListIterator listIterator()：List集合特有的迭代器
* 该迭代器继承了Iterator迭代器，所以，就可以直接使用hasNext()和next()方法。
* 特有功能：
* Object previous():获取上一个元素
* boolean hasPrevious():判断是否有元素
*
* 注意：ListIterator可以实现逆向遍历，但是必须先正向遍历，才能逆向遍历，所以一般无意义，不使用。
*/
public class ListIteratorDemo {
public static void main(String[] args) {
// 创建List集合对象
List list = new ArrayList();
list.add("hello");
list.add("world");
list.add("java");
// ListIterator listIterator()
ListIterator lit = list.listIterator(); // 子类对象
// while (lit.hasNext()) {
// String s = (String) lit.next();
// System.out.println(s);
// }
// System.out.println("-----------------");
// System.out.println(lit.previous());
// System.out.println(lit.previous());
// System.out.println(lit.previous());
// NoSuchElementException
// System.out.println(lit.previous());
while (lit.hasPrevious()) {
String s = (String) lit.previous();
System.out.println(s);
}
System.out.println("-----------------");
// 迭代器
Iterator it = list.iterator();
while (it.hasNext()) {
String s = (String) it.next();
System.out.println(s);
}
System.out.println("-----------------");
}
}
|
|
/*
* 问题?
* 我有一个集合，如下，请问，我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现。
*
* ConcurrentModificationException:当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。
* 产生的原因：
* 迭代器是依赖于集合而存在的，在判断成功后，集合的中新添加了元素，而迭代器却不知道，所以就报错了，这个错叫并发修改异常。
* 其实这个问题描述的是：迭代器遍历元素的时候，通过集合是不能修改元素的。
* 如何解决呢?
* A:迭代器迭代元素，迭代器修改元素
* 元素是跟在刚才迭代的元素后面的。
* B:集合遍历元素，集合修改元素(普通for)
* 元素在最后添加的。
*/
public class ListIteratorDemo2 {
public static void main(String[] args) {
// 创建List集合对象
List list = new ArrayList();
// 添加元素
list.add("hello");
list.add("world");
list.add("java");
// 迭代器遍历 会报java.util.ConcurrentModificationException异常
// Iterator it = list.iterator();
// while (it.hasNext()) {
// String s = (String) it.next();
// if ("world".equals(s)) {
// list.add("javaee");
// }
// }
// 方式1：迭代器迭代元素，迭代器修改元素
// 而Iterator迭代器却没有添加功能，所以我们使用其子接口ListIterator
// ListIterator lit = list.listIterator();
// while (lit.hasNext()) {
// String s = (String) lit.next();
// if ("world".equals(s)) {
// lit.add("javaee");
// }
// }
// 方式2：集合遍历元素，集合修改元素(普通for)
for (int x = 0; x < list.size(); x++) {
String s = (String) list.get(x);
if ("world".equals(s)) {
list.add("javaee");
}
}
System.out.println("list:" + list);
}
}
4. ArrayList
一、ArrayList就是传说中的动态数组，就是Array的复杂版本，它提供了如下一些好处：
（1）动态的增加和减少元素
（2）实现了Collection和List接口
（3）灵活的设置数组的大小
1、构造方法摘要
（1）ArrayList()
构造一个初始容量为 10 的空列表。
（2）ArrayList(Collection<? extends E> c)
构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
（3）ArrayList(int initialCapacity)
构造一个具有指定初始容量的空列表。
|
|
/*
* List的子类特点：
* ArrayList:
* 底层数据结构是数组，查询快，增删慢
* 线程不安全，效率高
* Vector:
* 底层数据结构是数组，查询快，增删慢
* 线程安全，效率低
* LinkedList:
* 底层数据结构是链表，查询慢，增删快
* 线程不安全，效率高
* 案例：
* 使用List的任何子类存储字符串或者存储自定义对象并遍历。
* ArrayList的使用。
* 存储字符串并遍历
*/
public class ArrayListDemo {
public static void main(String[] args) {
// 创建集合对象
ArrayList array = new ArrayList();
// 创建元素对象，并添加元素
array.add("hello");
array.add("world");
array.add("java");
// 遍历
Iterator it = array.iterator();
while (it.hasNext()) {
String s = (String) it.next();
System.out.println(s);
}
System.out.println("-----------");
for (int x = 0; x < array.size(); x++) {
String s = (String) array.get(x);
System.out.println(s);
}
}
}
|
|
/*
* ArrayList存储自定义对象并遍历
*/
public class ArrayListDemo2 {
public static void main(String[] args) {
// 创建集合对象
ArrayList array = new ArrayList();
// 创建学生对象
Student s1 = new Student("武松", 30);
Student s2 = new Student("鲁智深", 40);
Student s3 = new Student("林冲", 36);
Student s4 = new Student("杨志", 38);
// 添加元素
array.add(s1);
array.add(s2);
array.add(s3);
array.add(s4);
// 遍历
Iterator it = array.iterator();
while (it.hasNext()) {
Student s = (Student) it.next();
System.out.println(s.getName() + "---" + s.getAge());
}
System.out.println("----------------");
for (int x = 0; x < array.size(); x++) {
// ClassCastException 注意，千万要搞清楚类型
// String s = (String) array.get(x);
// System.out.println(s);
Student s = (Student) array.get(x);
System.out.println(s.getName() + "---" + s.getAge());
}
}
}
|
|
/*
* ArrayList去除集合中字符串的重复值(字符串的内容相同)
*
* 分析：
* A:创建集合对象
* B:添加多个字符串元素(包含内容相同的)
* C:创建新集合
* D:遍历旧集合,获取得到每一个元素
* E:拿这个元素到新集合去找，看有没有
* 有：不搭理它
* 没有：就添加到新集合
* F:遍历新集合
*/
public class ArrayListDemo {
public static void main(String[] args) {
// 创建集合对象
ArrayList array = new ArrayList();
// 添加多个字符串元素(包含内容相同的)
array.add("hello");
array.add("world");
array.add("java");
array.add("world");
array.add("java");
array.add("world");
array.add("world");
array.add("world");
array.add("world");
array.add("java");
array.add("world");
// 创建新集合
ArrayList newArray = new ArrayList();
// 遍历旧集合,获取得到每一个元素
Iterator it = array.iterator();
while (it.hasNext()) {
String s = (String) it.next();
// 拿这个元素到新集合去找，看有没有
if (!newArray.contains(s)) {
newArray.add(s);
}
}
// 遍历新集合
for (int x = 0; x < newArray.size(); x++) {
String s = (String) newArray.get(x);
System.out.println(s);
}
}
}
|
|
/*
* 需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
* 要求：不能创建新的集合，就在以前的集合上做。
*/
public class ArrayListDemo2 {
public static void main(String[] args) {
// 创建集合对象
ArrayList array = new ArrayList();
// 添加多个字符串元素(包含内容相同的)
array.add("hello");
array.add("world");
array.add("java");
array.add("world");
array.add("java");
array.add("world");
array.add("world");
array.add("world");
array.add("world");
array.add("java");
array.add("world");
// 由选择排序思想引入，我们就可以通过这种思想做这个题目
// 拿0索引的依次和后面的比较，有就把后的干掉
// 同理，拿1索引...
for (int x = 0; x < array.size() - 1; x++) {
for (int y = x + 1; y < array.size(); y++) {
if (array.get(x).equals(array.get(y))) {
array.remove(y);
y--;
}
}
}
// 遍历集合
Iterator it = array.iterator();
while (it.hasNext()) {
String s = (String) it.next();
System.out.println(s);
}
}
}
|
|
/*
* 需求：去除集合中自定义对象的重复值(对象的成员变量值都相同)
*
* 我们按照和字符串一样的操作，发现出问题了。
* 为什么呢?
* 我们必须思考哪里会出问题?
* 通过简单的分析，我们知道问题出现在了判断上。
* 而这个判断功能是集合自己提供的，所以我们如果想很清楚的知道它是如何判断的，就应该去看源码。
* contains()方法的底层依赖的是equals()方法。
* 而我们的学生类中没有equals()方法，这个时候，默认使用的是它父亲Object的equals()方法
* Object()的equals()默认比较的是地址值，所以，它们进去了。因为new的东西，地址值都不同。
* 按照我们自己的需求，比较成员变量的值，重写equals()即可。
* 自动生成即可。
*/
public class ArrayListDemo3 {
public static void main(String[] args) {
// 创建集合对象
ArrayList array = new ArrayList();
// 创建学生对象
Student s1 = new Student("林青霞", 27);
Student s2 = new Student("林志玲", 40);
Student s3 = new Student("凤姐", 35);
Student s4 = new Student("芙蓉姐姐", 18);
Student s5 = new Student("翠花", 16);
Student s6 = new Student("林青霞", 27);
Student s7 = new Student("林青霞", 18);
// 添加元素
array.add(s1);
array.add(s2);
array.add(s3);
array.add(s4);
array.add(s5);
array.add(s6);
array.add(s7);
// 创建新集合
ArrayList newArray = new ArrayList();
// 遍历旧集合,获取得到每一个元素
Iterator it = array.iterator();
while (it.hasNext()) {
Student s = (Student) it.next();
// 拿这个元素到新集合去找，看有没有
if (!newArray.contains(s)) {
newArray.add(s);
}
}
// 遍历新集合
for (int x = 0; x < newArray.size(); x++) {
Student s = (Student) newArray.get(x);
System.out.println(s.getName() + "---" + s.getAge());
}
}
}
|
|
/*
* ArrayList存储字符串并遍历。要求加入泛型，并用增强for遍历。
* A:迭代器
* B:普通for
* C:增强for
*/
public class ArrayListDemo {
public static void main(String[] args) {
// 创建集合对象
ArrayList<String> array = new ArrayList<String>();
// 创建并添加元素
array.add("hello");
array.add("world");
array.add("java");
// 遍历集合
// 迭代器
Iterator<String> it = array.iterator();
while (it.hasNext()) {
String s = it.next();
System.out.println(s);
}
System.out.println("------------------");
// 普通for
for (int x = 0; x < array.size(); x++) {
String s = array.get(x);
System.out.println(s);
}
System.out.println("------------------");
// 增强for
for (String s : array) {
System.out.println(s);
}
}
}
|
|
/*
* 需求：ArrayList存储自定义对象并遍历。要求加入泛型，并用增强for遍历。
* A:迭代器
* B:普通for
* C:增强for
*
* LinkedList,Vector,Colleciton,List等存储我还讲吗?不讲解了，但是要求你们练习。
*
* 增强for是用来替迭代器。
*/
public class ArrayListDemo2 {
public static void main(String[] args) {
// 创建集合对象
ArrayList<Student> array = new ArrayList<Student>();
// 创建学生对象
Student s1 = new Student("林青霞", 27);
Student s2 = new Student("貂蝉", 22);
Student s3 = new Student("杨玉环", 24);
Student s4 = new Student("西施", 21);
Student s5 = new Student("王昭君", 23);
// 把学生对象添加到集合中
array.add(s1);
array.add(s2);
array.add(s3);
array.add(s4);
array.add(s5);
// 迭代器
Iterator<Student> it = array.iterator();
while (it.hasNext()) {
Student s = it.next();
System.out.println(s.getName() + "---" + s.getAge());
}
System.out.println("---------------");
// 普通for
for (int x = 0; x < array.size(); x++) {
Student s = array.get(x);
System.out.println(s.getName() + "---" + s.getAge());
}
System.out.println("---------------");
// 增强for
for (Student s : array) {
System.out.println(s.getName() + "---" + s.getAge());
}
}
}
5. Vector
1、Vector 可实现自动增长的对象数组。
(1) java.util.vector提供了向量类(vector)以实现类似动态数组的功能。在Java语言中没有指针的概念，但如果正确灵活地使用指针又确实可以大大提高程序的质量。比如在c,c++中所谓的“动态数组”一般都由指针来实现。为了弥补这个缺点，Java提供了丰富的类库来方便编程者使用，vector类便是其中之一。事实上，灵活使用数组也可以完成向量类的功能，但向量类中提供大量的方法大大方便了用户的使用。
(2) 创建了一个向量类的对象后，可以往其中随意插入不同类的对象，即不需顾及类型也不需预先选定向量的容量，并可以方便地进行查找。对于预先不知或者不愿预先定义数组大小，并且需要频繁地进行查找，插入，删除工作的情况。可以考虑使用向量类。
2、Vector方法（自己看API文档）vector扩容2倍，ArrayList扩容1.5倍。
3、三种遍历Vector的方式（普通for循环，加强for循环，迭代器Iterator）
|
|
/*
* Vector的特有功能：
* 1：添加功能
* public void addElement(Object obj) -- add()
* 2：获取功能
* public Object elementAt(int index) -- get()
* public Enumeration elements() -- Iterator iterator()
* boolean hasMoreElements() hasNext()
* Object nextElement() next()
* JDK升级的原因：
* A:安全
* B:效率
* C:简化书写
*/
public class VectorDemo {
public static void main(String[] args) {
// 创建集合对象
Vector v = new Vector();
// 添加功能
v.addElement("hello");
v.addElement("world");
v.addElement("java");
// 遍历
for (int x = 0; x < v.size(); x++) {
String s = (String) v.elementAt(x);
System.out.println(s);
}
System.out.println("------------------");
Enumeration en = v.elements(); // 返回的是实现类的对象
while (en.hasMoreElements()) {
String s = (String) en.nextElement();
System.out.println(s);
}
}
}
6. LinkedList
1、LinkedList也和ArrayList一样实现了List接口，但是它执行插入和删除操作时比ArrayList更加高效，因为它是基于链表的。基于链表也决定了它在随机访问方面要比ArrayList逊色一点。
2、除此之外，LinkedList还提供了一些可以使其作为栈、队列、双端队列的方法。这些方法中有些彼此之间只是名称的区别，以使得这些名字在特定的上下文中显得更加的合适。
|
|
/*
* LinkedList的特有功能：
* A:添加功能
* public void addFirst(Object e)
* public void addLast(Object e)
* B:获取功能
* public Object getFirst()
* public Obejct getLast()
* C:删除功能
* public Object removeFirst()
* public Object removeLast()
*/
public class LinkedListDemo {
public static void main(String[] args) {
// 创建集合对象
LinkedList link = new LinkedList();
// 添加元素
link.add("hello");
link.add("world");
link.add("java");
// public void addFirst(Object e)
// link.addFirst("javaee");
// public void addLast(Object e)
// link.addLast("android");
// public Object getFirst()
// System.out.println("getFirst:" + link.getFirst());
// public Obejct getLast()
// System.out.println("getLast:" + link.getLast());
// public Object removeFirst()
System.out.println("removeFirst:" + link.removeFirst());
// public Object removeLast()
System.out.println("removeLast:" + link.removeLast());
// 输出对象名
System.out.println("link:" + link);
}
}
|
|
/*
*请用LinkedList模拟栈数据结构的集合，并测试
*题目的意思是：
* 你自己的定义一个集合类，在这个集合类内部可以使用LinkedList模拟。
*/
public class LinkedListDemo {
public static void main(String[] args) {
// A: LinkedList的特有添加功能addFirst()
// B:栈的特点先进后出
// 创建集合对象
// LinkedList link = new LinkedList();
//
// // 添加元素
// link.addFirst("hello");
// link.addFirst("world");
// link.addFirst("java");
//
// // 遍历
// Iterator it = link.iterator();
// while (it.hasNext()) {
// String s = (String) it.next();
// System.out.println(s);
// }
//为什么呢?
}
}
|
|
/**
* 自定义的栈集合
*/
public class MyStack {
private LinkedList link;
public MyStack() {
link = new LinkedList();
}
public void add(Object obj) {
link.addFirst(obj);
}
public Object get() {
// return link.getFirst();
return link.removeFirst();
}
public boolean isEmpty() {
return link.isEmpty();
}
}
|
|
/*
* MyStack的测试
*/
public class MyStackDemo {
public static void main(String[] args) {
// 创建集合对象
MyStack ms = new MyStack();
// 添加元素
ms.add("hello");
ms.add("world");
ms.add("java");
// System.out.println(ms.get());
// System.out.println(ms.get());
// System.out.println(ms.get());
// NoSuchElementException
// System.out.println(ms.get());
while(!ms.isEmpty()){
System.out.println(ms.get());
}
}
}
7. Set集合
1、Set集合(理解)
(1)Set集合的特点
无序,唯一
(2)HashSet集合(掌握)
A:底层数据结构是哈希表(是一个元素为链表的数组)
B:哈希表底层依赖两个方法：hashCode()和equals()
执行顺序：
首先比较哈希值是否相同
相同：继续执行equals()方法
返回true：元素重复了，不添加
返回false：直接把元素添加到集合
不同：就直接把元素添加到集合
C:如何保证元素唯一性的呢?
由hashCode()和equals()保证的
D:开发的时候，代码非常的简单，自动生成即可。
E:HashSet存储字符串并遍历
F:HashSet存储自定义对象并遍历(对象的成员变量值相同即为同一个元素)
(3)TreeSet集合
A:底层数据结构是红黑树(是一个自平衡的二叉树)
B:保证元素的排序方式
a:自然排序(元素具备比较性)
让元素所属的类实现Comparable接口
b:比较器排序(集合具备比较性)
让集合构造方法接收Comparator的实现类对象
C:把我们讲过的代码看一遍即可
(4)案例：
A:获取无重复的随机数
B:键盘录入学生按照总分从高到底输出
2、Collection集合总结(掌握)
Collection
|--List 有序,可重复
|--ArrayList
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高
|--Vector
底层数据结构是数组，查询快，增删慢。
线程安全，效率低
|--LinkedList
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高
|--Set 无序,唯一
|--HashSet
底层数据结构是哈希表。
如何保证元素唯一性的呢?
依赖两个方法：hashCode()和equals()
开发中自动生成这两个方法即可
|--LinkedHashSet
底层数据结构是链表和哈希表
由链表保证元素有序
由哈希表保证元素唯一
|--TreeSet
底层数据结构是红黑树。
如何保证元素排序的呢?
自然排序
比较器排序
如何保证元素唯一性的呢?
根据比较的返回值是否是0来决定
3、:针对Collection集合我们到底使用谁呢?(掌握)
唯一吗?
是：Set
排序吗?
是：TreeSet
否：HashSet
如果你知道是Set，但是不知道是哪个Set，就用HashSet。
否：List
要安全吗?
是：Vector
否：ArrayList或者LinkedList
查询多：ArrayList
增删多：LinkedList
如果你知道是List，但是不知道是哪个List，就用ArrayList。
如果你知道是Collection集合，但是不知道使用谁，就用ArrayList。
如果你知道用集合，就用ArrayList。
4:在集合中常见的数据结构(掌握)
ArrayXxx:底层数据结构是数组，查询快，增删慢
LinkedXxx:底层数据结构是链表，查询慢，增删快
HashXxx:底层数据结构是哈希表。依赖两个方法：hashCode()和equals()
TreeXxx:底层数据结构是二叉树。两种方式排序：自然排序和比较器排序
|
|
/*
* Collection
* |--List
* 有序(存储顺序和取出顺序一致),可重复
* |--Set
* 无序(存储顺序和取出顺序不一致),唯一
*
* HashSet：它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。
* 注意：虽然Set集合的元素无序，但是，作为集合来说，它肯定有它自己的存储顺序，
* 而你的顺序恰好和它的存储顺序一致，这代表不了有序，你可以多存储一些数据，就能看到效果。
*/
public class SetDemo {
public static void main(String[] args) {
// 创建集合对象
Set<String> set = new HashSet<String>();
// 创建并添加元素
set.add("hello");
set.add("java");
set.add("world");
set.add("java");
set.add("world");
// 增强for
for (String s : set) {
System.out.println(s);
}
}
}
|
|
8. HashSet
/*
* HashSet:存储字符串并遍历
* 问题：为什么存储字符串的时候，字符串内容相同的只存储了一个呢?
* 通过查看add方法的源码，我们知道这个方法底层依赖 两个方法：hashCode()和equals()。
* 步骤：
* 首先比较哈希值
* 如果相同，继续走，比较地址值或者走equals()
* 如果不同,就直接添加到集合中
* 按照方法的步骤来说：
* 先看hashCode()值是否相同
* 相同:继续走equals()方法
* 返回true： 说明元素重复，就不添加
* 返回false：说明元素不重复，就添加到集合
* 不同：就直接把元素添加到集合
* 如果类没有重写这两个方法，默认使用的Object()。一般来说不同相同。
* 而String类重写了hashCode()和equals()方法，所以，它就可以把内容相同的字符串去掉。只留下一个。
*/
public class HashSetDemo {
public static void main(String[] args) {
// 创建集合对象
HashSet<String> hs = new HashSet<String>();
// 创建并添加元素
hs.add("hello");
hs.add("world");
hs.add("java");
hs.add("world");
// 遍历集合
for (String s : hs) {
System.out.println(s);
}
}
}
|
|
/*
* 需求：存储自定义对象，并保证元素的唯一性
* 要求：如果两个对象的成员变量值都相同，则为同一个元素。
*
* 目前是不符合我的要求的：因为我们知道HashSet底层依赖的是hashCode()和equals()方法。
* 而这两个方法我们在学生类中没有重写，所以，默认使用的是Object类。
* 这个时候，他们的哈希值是不会一样的，根本就不会继续判断，执行了添加操作。
*/
public class HashSetDemo2 {
public static void main(String[] args) {
// 创建集合对象
HashSet<Student> hs = new HashSet<Student>();
// 创建学生对象
Student s1 = new Student("林青霞", 27);
Student s2 = new Student("柳岩", 22);
Student s3 = new Student("王祖贤", 30);
Student s4 = new Student("林青霞", 27);
Student s5 = new Student("林青霞", 20);
Student s6 = new Student("范冰冰", 22);
// 添加元素
hs.add(s1);
hs.add(s2);
hs.add(s3);
hs.add(s4);
hs.add(s5);
hs.add(s6);
// 遍历集合
for (Student s : hs) {
System.out.println(s.getName() + "---" + s.getAge());
}
}
}
|
|
/*
* HashSet集合存储自定义对象并遍历。如果对象的成员变量值相同即为同一个对象
*
* 注意了：
* 你使用的是HashSet集合，这个集合的底层是哈希表结构。
* 而哈希表结构底层依赖:hashCode()和equals()方法。
* 如果你认为对象的成员变量值相同即为同一个对象的话，你就应该重写这两个方法。
* 如何重写呢?不同担心，自动生成即可。
*/
public class DogDemo {
public static void main(String[] args) {
// 创建集合对象
HashSet<Dog> hs = new HashSet<Dog>();
// 创建狗对象
Dog d1 = new Dog("秦桧", 25, "红色", '男');
Dog d2 = new Dog("高俅", 22, "黑色", '女');
Dog d3 = new Dog("秦桧", 25, "红色", '男');
Dog d4 = new Dog("秦桧", 20, "红色", '女');
Dog d5 = new Dog("魏忠贤", 28, "白色", '男');
Dog d6 = new Dog("李莲英", 23, "黄色", '女');
Dog d7 = new Dog("李莲英", 23, "黄色", '女');
Dog d8 = new Dog("李莲英", 23, "黄色", '男');
// 添加元素
hs.add(d1);
hs.add(d2);
hs.add(d3);
hs.add(d4);
hs.add(d5);
hs.add(d6);
hs.add(d7);
hs.add(d8);
// 遍历
for (Dog d : hs) {
System.out.println(d.getName() + "---" + d.getAge() + "---"
+ d.getColor() + "---" + d.getSex());
}
}
}
|
|
/*
* 编写一个程序，获取10个数1至20的随机数，要求随机数不能重复。
*
* 分析：
* A:创建随机数对象
* B:创建一个HashSet集合
* C:判断集合的长度是不是小于10
* 是：就创建一个随机数添加
* 否：不搭理它
* D:遍历HashSet集合
*/
public class HashSetDemo {
public static void main(String[] args) {
// 创建随机数对象
Random r = new Random();
// 创建一个Set集合
HashSet<Integer> ts = new HashSet<Integer>();
// 判断集合的长度是不是小于10
while (ts.size() < 10) {
int num = r.nextInt(20) + 1;
ts.add(num);
}
// 遍历Set集合
for (Integer i : ts) {
System.out.println(i);
}
}
}
9. LinkedHashSet
|
|
/*
* LinkedHashSet:底层数据结构由哈希表和链表组成。
* 哈希表保证元素的唯一性。
* 链表保证元素有序。(存储和取出是一致)
*/
public class LinkedHashSetDemo {
public static void main(String[] args) {
// 创建集合对象
LinkedHashSet<String> hs = new LinkedHashSet<String>();
// 创建并添加元素
hs.add("hello");
hs.add("world");
hs.add("java");
hs.add("world");
hs.add("java");
// 遍历
for (String s : hs) {
System.out.println(s);
}
}
}
|
|
10. TreeSet
/*
* TreeSet：能够对元素按照某种规则进行排序。
* 排序有两种方式
* A:自然排序
* B:比较器排序
* TreeSet集合的特点：排序和唯一
* 通过观察TreeSet的add()方法，我们知道最终要看TreeMap的put()方法。
*/
1、内部比较器的实现
实现内部比较器步骤：
a、自定义类实现comparable<要比较的类>接口;
b、在自定义类中重写compareTo<要比较的类>的方法与this.属性比较
c、在主方法中：集合类型<自定义类类名> = new 集合类型<自定义类类名>（）；
注：自定义类名是指含有属性和方法的类。
（1）所有可以“排序”的类都实现了java.lang.Comparable 接口，Comparable接口中只有一个方法
public int compareTo(Object obj)；
（2）该方法:
返回 0 表示 this == obj
返回 1 表示 this > obj
返回 -1 表示 this < obj
实现了Comparable 接口的类通过实现 comparaTo 方法从而确定该类对象的排序方式。
class BookCook implements Comparable<BookCook>{
private String title;
private double price;
public BookCook(String title,double price){
this.title = title;
this.price = price;
}
@Override
public String toString() {
return "书名："+this.title+",价格："+this.price;
}
@Override
public int compareTo(BookCook o) {
if(this.price > o.price){
return 1;
}else if(this.price < o.price){
return -1;
}else{
return 0;
}
}
}
public class TreeSetDemo2 {
public static void main(String[] args) {
// 外部比较器定义
TreeSet<Person> ts = new TreeSet<Person>();
Person p1 = new Person("小白", 12, "男", 1000);
Person p2 = new Person("小白1", 12, "男", 1000);
Person p3 = new Person("小灰", 23, "女", 2000);
Person p4 = new Person("小红", 34, "男", 3000);
Person p5 = new Person("小绿", 45, "男", 3000);
ts.add(p1);
ts.add(p2);
ts.add(p3);
ts.add(p4);
ts.add(p5);
System.out.println(ts);
}
}
|
|
2、实现外部比较器：
（1）定义一个新的类B，实现comparator<自定义类类名A>接口
（2）在新的类B，重写compare<自定义类类名A a1,自定义类类名A a2>的方法; 注：a1.属性与a2.属性 进行比较
（3）在主方法中：集合类型<自定义类类名A> = new 集合类型<自定义类类名A>（new B()）；
注：实现comparator接口的类，可以叫做具有比较器的类。
//外部比较器
class MyComparetor implements Comparator<Person> {
@Override
public int compare(Person o1, Person o2) {
if (o1.getSalary() > o2.getSalary()) {
return 1;
} else if (o1.getSalary() < o2.getSalary()) {
return -1;
} else {
if (o1.getAge() > o2.getAge()) {
return 1;
} else if (o1.getAge() < o2.getAge()) {
return -1;
} else {
if (o1.getName().length() > o2.getName().length()) {
return 1;
} else if (o1.getName().length() < o2.getName().length()) {
return -1;
} else {
return 0;
}
}
}
}
}
public class TreeSetDemo2 {
public static void main(String[] args) {
// 外部比较器定义
TreeSet<Person> ts = new TreeSet<Person>(new MyComparetor());
Person p1 = new Person("小白", 12, "男", 1000);
Person p2 = new Person("小白1", 12, "男", 1000);
Person p3 = new Person("小灰", 23, "女", 2000);
Person p4 = new Person("小红", 34, "男", 3000);
Person p5 = new Person("小绿", 45, "男", 3000);
ts.add(p1);
ts.add(p2);
ts.add(p3);
ts.add(p4);
ts.add(p5);
System.out.println(ts);
}
}
|
|
3、实现匿名比较器：
集合类型<自定义类类名A> = new 集合类型<自定义类类名A>（new Comparator<自定义类类名A>(){
重写compare<自定义类类名A a1,自定义类类名A a2>的方法
）；
public class TreeSetDemo2 {
public static void main(String[] args) {
// （a2）1、内部比较器定义
// TreeSet<Person> ts = new TreeSet<Person>();
// （b2）2、外部比较器定义
// TreeSet<Person> ts = new TreeSet<Person>(new MyComparetor());
// （c1）3、使用匿名内部类来实现比较器
TreeSet<Person> ts = new TreeSet<Person>(new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
// 3、多重嵌套if循环
/*
* if (o1.getSalary() > o2.getSalary()) { return 1; } else if
* (o1.getSalary() < o2.getSalary()) { return -1; } else { if
* (o1.getAge() > o2.getAge()) { return 1; } else if
* (o1.getAge() < o2.getAge()) { return -1; } else { if
* (o1.getName().length() > o2.getName().length()) { return 1; }
* else if (o1.getName().length() < o2.getName() .length()) {
* return -1; } else { return 0; } } }
*/
// 3、??能否使用三目运算符实现
return o1.getSalary() > o2.getSalary() ? 1
: o1.getSalary() < o2.getSalary() ? -1
: o1.getAge() > o2.getAge() ? 1
: o1.getAge() < o2.getAge() ? -1 : o1
.getName().length() > o2
.getName().length() ? 1 : o1
.getName().length() < o2
.getName().length() ? -1 : 0;
}
});
Person p1 = new Person("小白", 12, "男", 1000);
Person p2 = new Person("小白1", 12, "男", 1000);
Person p3 = new Person("小灰", 23, "女", 2000);
Person p4 = new Person("小红", 34, "男", 3000);
Person p5 = new Person("小绿", 45, "男", 3000);
ts.add(p1);
ts.add(p2);
ts.add(p3);
ts.add(p4);
ts.add(p5);
System.out.println(ts);
}
}
11. Map集合
|
|
/*
* 作为学生来说，是根据学号来区分不同的学生的，那么假设我现在已经知道了学生的学号，我要根据学号去获取学生姓名，请问怎么做呢?
* 如果采用前面讲解过的集合，我们只能把学号和学生姓名作为一个对象的成员，然后存储整个对象，将来遍历的时候，判断，获取对应的名称。
* 但是呢，如果我都能把学生姓名拿出来了，我还需要根据编号去找吗?
* 针对我们目前的这种需求：仅仅知道学号，就想知道学生姓名的情况，Java就提供了一种新的集合 Map。
* 通过查看API，我们知道Map集合的一个最大的特点，就是它可以存储键值对的元素。这个时候存储我们上面的需求，就可以这样做
* 学号1 姓名1
* 学号2 姓名2
* 学号3 姓名3
* 学号2(不行) 姓名4
* 学号4 姓名4
* Map集合的特点：
* 将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
*
* Map集合和Collection集合的区别?
* Map集合存储元素是成对出现的，Map集合的键是唯一的，值是可重复的。可以把这个理解为：夫妻对
* Collection集合存储元素是单独出现的，Collection的儿子Set是唯一的，List是可重复的。可以把这个理解为：光棍(11.11)
*
* 注意：
* Map集合的数据结构值针对键有效，跟值无关
* HashMap，TreeMap等会讲。
* Collection集合的数据结构是针对元素有效
*
* Map集合的功能概述：
* 1:添加功能
* V put(K key,V value):添加元素。这个其实还有另一个功能?先不告诉你，等会讲
* 如果键是第一次存储，就直接存储元素，返回null
* 如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
* 2:删除功能
* void clear():移除所有的键值对元素
* V remove(Object key)：根据键删除键值对元素，并把值返回
* 3:判断功能
* boolean containsKey(Object key)：判断集合是否包含指定的键
* boolean containsValue(Object value):判断集合是否包含指定的值
* boolean isEmpty()：判断集合是否为空
* 4:获取功能
* Set<Map.Entry<K,V>> entrySet():???
* V get(Object key):根据键获取值
* Set<K> keySet():获取集合中所有键的集合
* Collection<V> values():获取集合中所有值的集合
* 5：长度功能
* int size()：返回集合中的键值对的对数
*/
public class MapDemo {
public static void main(String[] args) {
// 创建集合对象
Map<String, String> map = new HashMap<String, String>();
// 添加元素
// V put(K key,V value):添加元素。这个其实还有另一个功能?先不告诉你，等会讲
// System.out.println("put:" + map.put("文章", "马伊俐"));
// System.out.println("put:" + map.put("文章", "姚笛"));
map.put("邓超", "孙俪");
map.put("黄晓明", "杨颖");
map.put("周杰伦", "蔡依林");
map.put("刘恺威", "杨幂");
// void clear():移除所有的键值对元素
// map.clear();
// V remove(Object key)：根据键删除键值对元素，并把值返回
// System.out.println("remove:" + map.remove("黄晓明"));
// System.out.println("remove:" + map.remove("黄晓波"));
// boolean containsKey(Object key)：判断集合是否包含指定的键
// System.out.println("containsKey:" + map.containsKey("黄晓明"));
// System.out.println("containsKey:" + map.containsKey("黄晓波"));
// boolean isEmpty()：判断集合是否为空
// System.out.println("isEmpty:"+map.isEmpty());
//int size()：返回集合中的键值对的对数
System.out.println("size:"+map.size());
// 输出集合名称
System.out.println("map:" + map);
}
}
|
|
/*
* 获取功能：
* V get(Object key):根据键获取值
* Set<K> keySet():获取集合中所有键的集合
* Collection<V> values():获取集合中所有值的集合
*/
public class MapDemo2 {
public static void main(String[] args) {
// 创建集合对象
Map<String, String> map = new HashMap<String, String>();
// 创建元素并添加元素
map.put("邓超", "孙俪");
map.put("黄晓明", "杨颖");
map.put("周杰伦", "蔡依林");
map.put("刘恺威", "杨幂");
// V get(Object key):根据键获取值
System.out.println("get:" + map.get("周杰伦"));
System.out.println("get:" + map.get("周杰")); // 返回null
System.out.println("----------------------");
// Set<K> keySet():获取集合中所有键的集合
Set<String> set = map.keySet();
for (String key : set) {
System.out.println(key);
}
System.out.println("----------------------");
// Collection<V> values():获取集合中所有值的集合
Collection<String> con = map.values();
for (String value : con) {
System.out.println(value);
}
}
}
|
|
/*
* Map集合的遍历。
* Map -- 夫妻对
* 思路：
* A:把所有的丈夫给集中起来。
* B:遍历丈夫的集合，获取得到每一个丈夫。
* C:让丈夫去找自己的妻子。
*
* 转换：
* A:获取所有的键
* B:遍历键的集合，获取得到每一个键
* C:根据键去找值
*/
public class MapDemo3 {
public static void main(String[] args) {
// 创建集合对象
Map<String, String> map = new HashMap<String, String>();
// 创建元素并添加到集合
map.put("杨过", "小龙女");
map.put("郭靖", "黄蓉");
map.put("杨康", "穆念慈");
map.put("陈玄风", "梅超风");
// 遍历
// 获取所有的键
Set<String> set = map.keySet();
// 遍历键的集合，获取得到每一个键
for (String key : set) {
// 根据键去找值
String value = map.get(key);
System.out.println(key + "---" + value);
}
}
}
|
|
/*
* Map集合的遍历。
* Map -- 夫妻对
*
* 思路：
* A:获取所有结婚证的集合
* B:遍历结婚证的集合，得到每一个结婚证
* C:根据结婚证获取丈夫和妻子
*
* 转换：
* A:获取所有键值对对象的集合
* B:遍历键值对对象的集合，得到每一个键值对对象
* C:根据键值对对象获取键和值
*
* 这里面最麻烦的就是键值对对象如何表示呢?
* 看看我们开始的一个方法：
* Set<Map.Entry<K,V>> entrySet()：返回的是键值对对象的集合
*/
public class MapDemo4 {
public static void main(String[] args) {
// 创建集合对象
Map<String, String> map = new HashMap<String, String>();
// 创建元素并添加到集合
map.put("杨过", "小龙女");
map.put("郭靖", "黄蓉");
map.put("杨康", "穆念慈");
map.put("陈玄风", "梅超风");
// 获取所有键值对对象的集合
Set<Map.Entry<String, String>> set = map.entrySet();
// 遍历键值对对象的集合，得到每一个键值对对象
for (Map.Entry<String, String> me : set) {
// 根据键值对对象获取键和值
String key = me.getKey();
String value = me.getValue();
System.out.println(key + "---" + value);
}
}
}
|
|
12. HashMap
|
|
/*
* HashMap:是基于哈希表的Map接口实现。
* 哈希表的作用是用来保证键的唯一性的。
*
* HashMap<String,String>
* 键：String
* 值：String
*/
public class HashMapDemo {
public static void main(String[] args) {
// 创建集合对象
HashMap<String, String> hm = new HashMap<String, String>();
// 创建元素并添加元素
// String key1 = "it001";
// String value1 = "马云";
// hm.put(key1, value1);
hm.put("it001", "马云");
hm.put("it003", "马化腾");
hm.put("it004", "乔布斯");
hm.put("it005", "张朝阳");
hm.put("it002", "裘伯君"); // wps
hm.put("it001", "比尔盖茨");
// 遍历
Set<String> set = hm.keySet();
for (String key : set) {
String value = hm.get(key);
System.out.println(key + "---" + value);
}
}
}
|
|
/*
* HashMap<Integer,String>
* 键：Integer
* 值：String
*/
public class HashMapDemo2 {
public static void main(String[] args) {
// 创建集合对象
HashMap<Integer, String> hm = new HashMap<Integer, String>();
// 创建元素并添加元素
// Integer i = new Integer(27);
// Integer i = 27;
// String s = "林青霞";
// hm.put(i, s);
hm.put(27, "林青霞");
hm.put(30, "风清扬");
hm.put(28, "刘意");
hm.put(29, "林青霞");
// 下面的写法是八进制，但是不能出现8以上的单个数据
// hm.put(003, "hello");
// hm.put(006, "hello");
// hm.put(007, "hello");
// hm.put(008, "hello");
// 遍历
Set<Integer> set = hm.keySet();
for (Integer key : set) {
String value = hm.get(key);
System.out.println(key + "---" + value);
}
// 下面这种方式仅仅是集合的元素的字符串表示
// System.out.println("hm:" + hm);
}
}
|
|
/*
* HashMap<String,Student>
* 键：String 学号
* 值：Student 学生对象
*/
public class HashMapDemo3 {
public static void main(String[] args) {
// 创建集合对象
HashMap<String, Student> hm = new HashMap<String, Student>();
// 创建学生对象
Student s1 = new Student("周星驰", 58);
Student s2 = new Student("刘德华", 55);
Student s3 = new Student("梁朝伟", 54);
Student s4 = new Student("刘嘉玲", 50);
// 添加元素
hm.put("9527", s1);
hm.put("9522", s2);
hm.put("9524", s3);
hm.put("9529", s4);
// 遍历
Set<String> set = hm.keySet();
for (String key : set) {
// 注意了：这次值不是字符串了
// String value = hm.get(key);
Student value = hm.get(key);
System.out.println(key + "---" + value.getName() + "---"
+ value.getAge());
}
}
}
|
|
/*
* HashMap<Student,String>
* 键：Student
* 要求：如果两个对象的成员变量值都相同，则为同一个对象。
* 值：String
*/
public class HashMapDemo4 {
public static void main(String[] args) {
// 创建集合对象
HashMap<Student, String> hm = new HashMap<Student, String>();
// 创建学生对象
Student s1 = new Student("貂蝉", 27);
Student s2 = new Student("王昭君", 30);
Student s3 = new Student("西施", 33);
Student s4 = new Student("杨玉环", 35);
Student s5 = new Student("貂蝉", 27);
// 添加元素
hm.put(s1, "8888");
hm.put(s2, "6666");
hm.put(s3, "5555");
hm.put(s4, "7777");
hm.put(s5, "9999");
// 遍历
Set<Student> set = hm.keySet();
for (Student key : set) {
String value = hm.get(key);
System.out.println(key.getName() + "---" + key.getAge() + "---"
+ value);
}
}
}
|
|
13. LinkedHashMap
|
|
/*
* LinkedHashMap:是Map接口的哈希表和链接列表实现，具有可预知的迭代顺序。
* 由哈希表保证键的唯一性
* 由链表保证键盘的有序(存储和取出的顺序一致)
*/
public class LinkedHashMapDemo {
public static void main(String[] args) {
// 创建集合对象
LinkedHashMap<String, String> hm = new LinkedHashMap<String, String>();
// 创建并添加元素
hm.put("2345", "hello");
hm.put("1234", "world");
hm.put("3456", "java");
hm.put("1234", "javaee");
hm.put("3456", "android");
// 遍历
Set<String> set = hm.keySet();
for (String key : set) {
String value = hm.get(key);
System.out.println(key + "---" + value);
}
}
}
|
|
14. TreeMap
/*
* TreeMap:是基于红黑树的Map接口的实现。
*
* HashMap<String,String>
* 键：String
* 值：String
*/
public class TreeMapDemo {
public static void main(String[] args) {
// 创建集合对象
TreeMap<String, String> tm = new TreeMap<String, String>();
// 创建元素并添加元素
tm.put("hello", "你好");
tm.put("world", "世界");
tm.put("java", "爪哇");
tm.put("world", "世界2");
tm.put("javaee", "爪哇EE");
// 遍历集合
Set<String> set = tm.keySet();
for (String key : set) {
String value = tm.get(key);
System.out.println(key + "---" + value);
}
}
}
|
|
/*
* TreeMap<Student,String>
* 键:Student
* 值：String
*/
public class TreeMapDemo2 {
public static void main(String[] args) {
// 创建集合对象
TreeMap<Student, String> tm = new TreeMap<Student, String>(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
// 主要条件
int num = s1.getAge() - s2.getAge();
// 次要条件
int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
return num2;
}
});
// 创建学生对象
Student s1 = new Student("潘安", 30);
Student s2 = new Student("柳下惠", 35);
Student s3 = new Student("唐伯虎", 33);
Student s4 = new Student("燕青", 32);
Student s5 = new Student("唐伯虎", 33);
// 存储元素
tm.put(s1, "宋朝");
tm.put(s2, "元朝");
tm.put(s3, "明朝");
tm.put(s4, "清朝");
tm.put(s5, "汉朝");
// 遍历
Set<Student> set = tm.keySet();
for (Student key : set) {
String value = tm.get(key);
System.out.println(key.getName() + "---" + key.getAge() + "---"
+ value);
}
}
}
|
|
/*
* 需求 ："aababcabcdabcde",获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)
*
* 分析：
* A:定义一个字符串(可以改进为键盘录入)
* B:定义一个TreeMap集合
* 键:Character
* 值：Integer
* C:把字符串转换为字符数组
* D:遍历字符数组，得到每一个字符
* E:拿刚才得到的字符作为键到集合中去找值，看返回值
* 是null:说明该键不存在，就把该字符作为键，1作为值存储
* 不是null:说明该键存在，就把值加1，然后重写存储该键和值
* F:定义字符串缓冲区变量
* G:遍历集合，得到键和值，进行按照要求拼接
* H:把字符串缓冲区转换为字符串输出
*
* 录入：linqingxia
* 结果：result:a(1)g(1)i(3)l(1)n(2)q(1)x(1)
*/
public class TreeMapDemo {
public static void main(String[] args) {
// 定义一个字符串(可以改进为键盘录入)
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String line = sc.nextLine();
// 定义一个TreeMap集合
TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>();
//把字符串转换为字符数组
char[] chs = line.toCharArray();
//遍历字符数组，得到每一个字符
for(char ch : chs){
//拿刚才得到的字符作为键到集合中去找值，看返回值
Integer i = tm.get(ch);
//是null:说明该键不存在，就把该字符作为键，1作为值存储
if(i == null){
tm.put(ch, 1);
}else {
//不是null:说明该键存在，就把值加1，然后重写存储该键和值
i++;
tm.put(ch,i);
}
}
//定义字符串缓冲区变量
StringBuilder sb= new StringBuilder();
//遍历集合，得到键和值，进行按照要求拼接
Set<Character> set = tm.keySet();
for(Character key : set){
Integer value = tm.get(key);
sb.append(key).append("(").append(value).append(")");
}
//把字符串缓冲区转换为字符串输出
String result = sb.toString();
System.out.println("result:"+result);
}
}
15. ArrayListIncludeHashMap
|
|
/*
ArrayList集合嵌套HashMap集合并遍历。
需求：
假设ArrayList集合的元素是HashMap。有3个。
每一个HashMap集合的键和值都是字符串。
元素我已经完成，请遍历。
结果：
周瑜---小乔
吕布---貂蝉
郭靖---黄蓉
杨过---小龙女
令狐冲---任盈盈
林平之---岳灵珊
*/
public class ArrayListIncludeHashMapDemo {
public static void main(String[] args) {
// 创建集合对象
ArrayList<HashMap<String, String>> array = new ArrayList<HashMap<String, String>>();
// 创建元素1
HashMap<String, String> hm1 = new HashMap<String, String>();
hm1.put("周瑜", "小乔");
hm1.put("吕布", "貂蝉");
// 把元素添加到array里面
array.add(hm1);
// 创建元素1
HashMap<String, String> hm2 = new HashMap<String, String>();
hm2.put("郭靖", "黄蓉");
hm2.put("杨过", "小龙女");
// 把元素添加到array里面
array.add(hm2);
// 创建元素1
HashMap<String, String> hm3 = new HashMap<String, String>();
hm3.put("令狐冲", "任盈盈");
hm3.put("林平之", "岳灵珊");
// 把元素添加到array里面
array.add(hm3);
// 遍历
for (HashMap<String, String> hm : array) {
Set<String> set = hm.keySet();
for (String key : set) {
String value = hm.get(key);
System.out.println(key + "---" + value);
}
}
}
}
|
|
16. HashMapIncludeArrayList
/*
*需求：
*假设HashMap集合的元素是ArrayList。有3个。
*每一个ArrayList集合的值是字符串。
*元素我已经完成，请遍历。
*结果：
* 三国演义
* 吕布
* 周瑜
* 笑傲江湖
* 令狐冲
* 林平之
* 神雕侠侣
* 郭靖
* 杨过
*/
public class HashMapIncludeArrayListDemo {
public static void main(String[] args) {
// 创建集合对象
HashMap<String, ArrayList<String>> hm = new HashMap<String, ArrayList<String>>();
// 创建元素集合1
ArrayList<String> array1 = new ArrayList<String>();
array1.add("吕布");
array1.add("周瑜");
hm.put("三国演义", array1);
// 创建元素集合2
ArrayList<String> array2 = new ArrayList<String>();
array2.add("令狐冲");
array2.add("林平之");
hm.put("笑傲江湖", array2);
// 创建元素集合3
ArrayList<String> array3 = new ArrayList<String>();
array3.add("郭靖");
array3.add("杨过");
hm.put("神雕侠侣", array3);
//遍历集合
Set<String> set = hm.keySet();
for(String key : set){
System.out.println(key);
ArrayList<String> value = hm.get(key);
for(String s : value){
System.out.println("\t"+s);
}
}
}
}
17. 比较器的实现
1、内部比较器的实现
实现内部比较器步骤：
a、自定义类实现comparable<要比较的类>接口;
b、在自定义类中重写compareTo<要比较的类>的方法与this.属性比较
c、在主方法中：集合类型<自定义类类名> = new 集合类型<自定义类类名>（）；
注：自定义类名是指含有属性和方法的类。
（1）所有可以“排序”的类都实现了java.lang.Comparable 接口，Comparable接口中只有一个方法
public int compareTo(Object obj)；
（2）该方法:
返回 0 表示 this == obj
返回 1 表示 this > obj
返回 -1 表示 this < obj
实现了Comparable 接口的类通过实现 comparaTo 方法从而确定该类对象的排序方式。
class BookCook implements Comparable<BookCook>{
private String title;
private double price;
public BookCook(String title,double price){
this.title = title;
this.price = price;
}
@Override
public String toString() {
return "书名："+this.title+",价格："+this.price;
}
@Override
public int compareTo(BookCook o) {
if(this.price > o.price){
return 1;
}else if(this.price < o.price){
return -1;
}else{
return 0;
}
}
}
public class TreeSetDemo2 {
public static void main(String[] args) {
// 外部比较器定义
TreeSet<Person> ts = new TreeSet<Person>();
Person p1 = new Person("小白", 12, "男", 1000);
Person p2 = new Person("小白1", 12, "男", 1000);
Person p3 = new Person("小灰", 23, "女", 2000);
Person p4 = new Person("小红", 34, "男", 3000);
Person p5 = new Person("小绿", 45, "男", 3000);
ts.add(p1);
ts.add(p2);
ts.add(p3);
ts.add(p4);
ts.add(p5);
System.out.println(ts);
}
}
|
|
2、实现外部比较器：
（1）定义一个新的类B，实现comparator<自定义类类名A>接口
（2）在新的类B，重写compare<自定义类类名A a1,自定义类类名A a2>的方法; 注：a1.属性与a2.属性 进行比较
（3）在主方法中：集合类型<自定义类类名A> = new 集合类型<自定义类类名A>（new B()）；
注：实现comparator接口的类，可以叫做具有比较器的类。
//外部比较器
class MyComparetor implements Comparator<Person> {
@Override
public int compare(Person o1, Person o2) {
if (o1.getSalary() > o2.getSalary()) {
return 1;
} else if (o1.getSalary() < o2.getSalary()) {
return -1;
} else {
if (o1.getAge() > o2.getAge()) {
return 1;
} else if (o1.getAge() < o2.getAge()) {
return -1;
} else {
if (o1.getName().length() > o2.getName().length()) {
return 1;
} else if (o1.getName().length() < o2.getName().length()) {
return -1;
} else {
return 0;
}
}
}
}
}
public class TreeSetDemo2 {
public static void main(String[] args) {
// 外部比较器定义
TreeSet<Person> ts = new TreeSet<Person>(new MyComparetor());
Person p1 = new Person("小白", 12, "男", 1000);
Person p2 = new Person("小白1", 12, "男", 1000);
Person p3 = new Person("小灰", 23, "女", 2000);
Person p4 = new Person("小红", 34, "男", 3000);
Person p5 = new Person("小绿", 45, "男", 3000);
ts.add(p1);
ts.add(p2);
ts.add(p3);
ts.add(p4);
ts.add(p5);
System.out.println(ts);
}
}
|
|
3、实现匿名比较器：
集合类型<自定义类类名A> = new 集合类型<自定义类类名A>（new Comparator<自定义类类名A>(){
重写compare<自定义类类名A a1,自定义类类名A a2>的方法
）；
public class TreeSetDemo2 {
public static void main(String[] args) {
TreeSet<Person> ts = new TreeSet<Person>(new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
// 3、多重嵌套if循环
/*
* if (o1.getSalary() > o2.getSalary()) { return 1; } else if
* (o1.getSalary() < o2.getSalary()) { return -1; } else { if
* (o1.getAge() > o2.getAge()) { return 1; } else if
* (o1.getAge() < o2.getAge()) { return -1; } else { if
* (o1.getName().length() > o2.getName().length()) { return 1; }
* else if (o1.getName().length() < o2.getName() .length()) {
* return -1; } else { return 0; } } }
*/
// 3、??能否使用三目运算符实现
return o1.getSalary() > o2.getSalary() ? 1
: o1.getSalary() < o2.getSalary() ? -1
: o1.getAge() > o2.getAge() ? 1
: o1.getAge() < o2.getAge() ? -1 : o1
.getName().length() > o2
.getName().length() ? 1 : o1
.getName().length() < o2
.getName().length() ? -1 : 0;
}
});
Person p1 = new Person("小白", 12, "男", 1000);
Person p2 = new Person("小白1", 12, "男", 1000);
Person p3 = new Person("小灰", 23, "女", 2000);
Person p4 = new Person("小红", 34, "男", 3000);
Person p5 = new Person("小绿", 45, "男", 3000);
ts.add(p1);
ts.add(p2);
ts.add(p3);
ts.add(p4);
ts.add(p5);
System.out.println(ts);
}
}
18. 遍历集合
1、遍历集合
（1）遍历List方法1，使用普通for循环：
for(int i=0;i<list.size();i++){
String temp = (String)list.get(i);
System.out.println(temp);
//list.remove(i); //遍历删除元素，不过不推荐这种方式！
}
（2）遍历List方法2，使用增强for循环(应该使用泛型定义类型！)：
for (String temp : list) {
System.out.println(temp);
（3） }
遍历List方法3，使用Iterator迭代器：(推荐这样写)
for(Iterator iter = list.iterator();iter.hasNext();){
String temp = (String)iter.next();
System.out.println(temp);
}
或者：
Iterator iter = c.iterator();
while(iter.hasNext()){
Object obj = iter.next();
iter.remove(); //如果要遍历删除集合中的元素，建议使用这种方式！
System.out.println(obj);
}
2、遍历Set：
（1）方法1，：
for(String temp:set){
System.out.println(temp);
}
（2）方法2，使用iterator迭代器
for(Iterator iter = set.iterator();iter.hasNext();){
String temp = (String)iter.next();
System.out.println(temp);
}
System.out.println(maps.get(id).name);
（3）//使用entrySet遍历
Set<Entry<Integer, String>> ss = map.entrySet();
for (Iterator iterator = ss.iterator(); iterator.hasNext();) {
Entry e = (Entry) iterator.next();
System.out.println(e.getKey()+"--"+e.getValue());
}
19. Collections工具类
Collections工具类
1、类 java.util.Collections 提供了对Set、List、Map操作的工具方法(排序、遍历)。
（1）void sort(List) //对List容器内的元素排序,排序的规则是按照升序进行排序。
（2）void shuffle(List) //对List容器内的元素进行随机排列
（3）void reverse(List) //对List容器内的元素进行逆续排列
（4）void fill(List, Object) //用一个特定的对象重写整个List容器
（5）int binarySearch(List, Object)//对于顺序的List容器，采用折半查找的 ，方法查找特定对象
注：进行二分查找必须先排序，否则返回的位置不正确
20. equals和hashcode
1、equals和hashcode方法：
（1）Collection类对象是否相等对象在调用remove、contains 等方法时需要比较，这会涉及到对象类型的 equals 方法和hashCode方法；对于自定义的类型，需要重写equals 和 hashCode 方法以实现自定义的对象相等规则。
注意：Java中规定，两个内容相同的对象应该具有相等的 hashcode
2、什么时候需要我们重写equal,hashcode方法？
（1）要将我们自定义的对象放入HashSet中处理。
（2）要将我们自定义的对象作为HashMap的key处理。
（3）放入Collection容器中的自定义对象后，可能会调用remove,contains等方法时。
4、equals和hashcode的关系和原理：
（1）Hashcode并不是内存地址，是内存地址转换而来的。系统通过它也可以确定内存地址。
（2）hashcode方法主要用在集合框架中，目的是为了快速比较两个对象是否相等，因为集合框架中的对象很多，每个都使用equals比较效率很差。
5、每个对象都有一个hashcode，规定：
（1）内容相同的对象hashcode肯定相等
（2）内容不相同的对象hashcode可能相等也可能不相等
（3）所以如果两个对象的hashcode不相等则两个对象的内容肯定不相等，这样就不必一个一个去比较属性的值了，从而提高对象比较的速度。
可以直接利用eclipse生成equal和hashcode方法，对于我们一般的程序来说已经足够了。
21. 泛型
泛型(掌握)
(1)泛型概述
是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。
(2)格式：
<数据类型>
注意：该数据类型只能是引用类型。
(3)好处：
A:把运行时期的问题提前到了编译期间
B:避免了强制类型转换
C:优化了程序设计，解决了黄色警告线问题，让程序更安全
(4)泛型的前世今生
A:泛型的由来
Object类型作为任意类型的时候，在向下转型的时候，会隐含一个转型问题
B:泛型类
C:泛型方法
D:泛型接口
E:泛型高级通配符
?
? extends E
? super E
(5)我们在哪里使用呢?
一般是在集合中使用。
|
|
/*
* ArrayList存储字符串并遍历
*
* 我们按照正常的写法来写这个程序， 结果确出错了。
* 为什么呢?
* 因为我们开始存储的时候，存储了String和Integer两种类型的数据。
* 而在遍历的时候，我们把它们都当作String类型处理的，做了转换，所以就报错了。
* 但是呢，它在编译期间却没有告诉我们。
* 所以，我就觉得这个设计的不好。
* 回想一下，我们的数组
* String[] strArray = new String[3];
* strArray[0] = "hello";
* strArray[1] = "world";
* strArray[2] = 10;
* 集合也模仿着数组的这种做法，在创建对象的时候明确元素的数据类型。这样就不会在有问题了。
* 而这种技术被称为：泛型。
*
* 泛型：是一种把类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。参数化类型，把类型当作参数一样的传递。
* 格式：
* <数据类型>
* 此处的数据类型只能是引用类型。
* 好处：
* A:把运行时期的问题提前到了编译期间
* B:避免了强制类型转换
* C:优化了程序设计，解决了黄色警告线
*/
|
|
/*
* 泛型在哪些地方使用呢?
* 看API，如果类，接口，抽象类后面跟的有<E>就说要使用泛型。一般来说就是在集合中使用。
*/
public class ArrayListDemo {
public static void main(String[] args) {
// 用ArrayList存储字符串元素，并遍历。用泛型改进代码
ArrayList<String> array = new ArrayList<String>();
array.add("hello");
array.add("world");
array.add("java");
Iterator<String> it = array.iterator();
while (it.hasNext()) {
String s = it.next();
System.out.println(s);
}
System.out.println("-----------------");
for (int x = 0; x < array.size(); x++) {
String s = array.get(x);
System.out.println(s);
}
}
}
|
|
/*
* 需求：存储自定义对象并遍历。
*
* A:创建学生类
* B:创建集合对象
* C:创建元素对象
* D:把元素添加到集合
* E:遍历集合
*/
public class ArrayListDemo2 {
public static void main(String[] args) {
// 创建集合对象
// JDK7的新特性：泛型推断。
// ArrayList<Student> array = new ArrayList<>();
// 但是我不建议这样使用。
ArrayList<Student> array = new ArrayList<Student>();
// 创建元素对象
Student s1 = new Student("曹操", 40); // 后知后觉
Student s2 = new Student("蒋干", 30); // 不知不觉
Student s3 = new Student("诸葛亮", 26);// 先知先觉
// 添加元素
array.add(s1);
array.add(s2);
array.add(s3);
// 遍历
Iterator<Student> it = array.iterator();
while (it.hasNext()) {
Student s = it.next();
System.out.println(s.getName() + "---" + s.getAge());
}
System.out.println("------------------");
for (int x = 0; x < array.size(); x++) {
Student s = array.get(x);
System.out.println(s.getName() + "---" + s.getAge());
}
}
}
|
|
/*
* 泛型高级(通配符)
* ?:任意类型，如果没有明确，那么就是Object以及任意的Java类了
* ? extends E:向下限定，E及其子类
* ? super E:向上限定，E极其父类
*/
class Animal {
}
class Dog extends Animal {
}
class Cat extends Animal {
}
public class GenericDemo {
public static void main(String[] args) {
// 泛型如果明确的写的时候，前后必须一致
Collection<Object> c1 = new ArrayList<Object>();
// Collection<Object> c2 = new ArrayList<Animal>();
// Collection<Object> c3 = new ArrayList<Dog>();
// Collection<Object> c4 = new ArrayList<Cat>();
// ?表示任意的类型都是可以的
Collection<?> c5 = new ArrayList<Object>();
Collection<?> c6 = new ArrayList<Animal>();
Collection<?> c7 = new ArrayList<Dog>();
Collection<?> c8 = new ArrayList<Cat>();
// ? extends E:向下限定，E及其子类
// Collection<? extends Animal> c9 = new ArrayList<Object>();
Collection<? extends Animal> c10 = new ArrayList<Animal>();
Collection<? extends Animal> c11 = new ArrayList<Dog>();
Collection<? extends Animal> c12 = new ArrayList<Cat>();
// ? super E:向上限定，E极其父类
Collection<? super Animal> c13 = new ArrayList<Object>();
Collection<? super Animal> c14 = new ArrayList<Animal>();
// Collection<? super Animal> c15 = new ArrayList<Dog>();
// Collection<? super Animal> c16 = new ArrayList<Cat>();
}
}
22. ObjectTool
/*
* 泛型类：把泛型定义在类上
*/
public class ObjectTool<T> {
private T obj;
public T getObj() {
return obj;
}
public void setObj(T obj) {
this.obj = obj;
}
}
|
|
/*
* 早期的时候，我们使用Object来代表任意的类型。
* 向上转型是没有任何问题的，但是在向下转型的时候其实隐含了类型转换的问题。
* 也就是说这样的程序其实并不是安全的。所以Java在JDK5后引入了泛型，提高程序的安全性。
*/
public class ObjectToolDemo {
public static void main(String[] args) {
ObjectTool ot = new ObjectTool();
// 正常使用
ot.setObj(new Integer(27));
Integer i = (Integer) ot.getObj();
System.out.println("年龄是：" + i);
ot.setObj(new String("林青霞"));
String s = (String) ot.getObj();
System.out.println("姓名是：" + s);
System.out.println("---------");
ot.setObj(new Integer(30));
// ClassCastException
String ss = (String) ot.getObj();
System.out.println("姓名是：" + ss);
}
}
|
|
/*
* 泛型类的测试
*/
public class ObjectToolDemo {
public static void main(String[] args) {
ObjectTool<String> ot = new ObjectTool<String>();
// ot.setObj(new Integer(27)); //这个时候编译期间就过不去
ot.setObj(new String("林青霞"));
String s = ot.getObj();
System.out.println("姓名是：" + s);
ObjectTool<Integer> ot2 = new ObjectTool<Integer>();
// ot2.setObj(new String("风清扬"));//这个时候编译期间就过不去
ot2.setObj(new Integer(27));
Integer i = ot2.getObj();
System.out.println("年龄是：" + i);
}
}
|
|
23. JDK5新特性
/*
* 静态导入：
* 格式：import static 包名….类名.方法名;
* 可以直接导入到方法的级别
*
* 静态导入的注意事项：
* A:方法必须是静态的
* B:如果有多个同名的静态方法，容易不知道使用谁?这个时候要使用，必须加前缀。由此可见，意义不大，所以一般不用，但是要能看懂。
*/
import static java.lang.Math.abs;
import static java.lang.Math.pow;
import static java.lang.Math.max;
//错误
//import static java.util.ArrayList.add;
public class StaticImportDemo {
public static void main(String[] args) {
// System.out.println(java.lang.Math.abs(-100));
// System.out.println(java.lang.Math.pow(2, 3));
// System.out.println(java.lang.Math.max(20, 30));
// 太复杂，我们就引入到import
// System.out.println(Math.abs(-100));
// System.out.println(Math.pow(2, 3));
// System.out.println(Math.max(20, 30));
// 太复杂，有更简单
// System.out.println(abs(-100));
System.out.println(java.lang.Math.abs(-100));
System.out.println(pow(2, 3));
System.out.println(max(20, 30));
}
public static void abs(String s){
System.out.println(s);
}
}
|
|
/*
* JDK5的新特性：自动拆装箱,泛型,增强for,静态导入,可变参数,枚举
*
* 增强for:是for循环的一种。
*
* 格式：
* for(元素数据类型 变量 : 数组或者Collection集合) {
* 使用变量即可，该变量就是元素
* }
*
* 好处：简化了数组和集合的遍历。
*
* 弊端： 增强for的目标不能为null。
* 如何解决呢?对增强for的目标先进行不为null的判断，然后在使用。
*/
public class ForDemo {
public static void main(String[] args) {
// 定义一个int数组
int[] arr = { 1, 2, 3, 4, 5 };
for (int x = 0; x < arr.length; x++) {
System.out.println(arr[x]);
}
System.out.println("---------------");
// 增强for
for (int x : arr) {
System.out.println(x);
}
System.out.println("---------------");
// 定义一个字符串数组
String[] strArray = { "林青霞", "风清扬", "东方不败", "刘意" };
// 增强for
for (String s : strArray) {
System.out.println(s);
}
System.out.println("---------------");
// 定义一个集合
ArrayList<String> array = new ArrayList<String>();
array.add("hello");
array.add("world");
array.add("java");
// 增强for
for (String s : array) {
System.out.println(s);
}
System.out.println("---------------");
List<String> list = null;
// NullPointerException
// 这个s是我们从list里面获取出来的，在获取前，它肯定还好做一个判断
// 说白了，这就是迭代器的功能
if (list != null) {
for (String s : list) {
System.out.println(s);
}
}
// 增强for其实是用来替代迭代器的
//ConcurrentModificationException
// for (String s : array) {
// if ("world".equals(s)) {
// array.add("javaee");
// }
// }
// System.out.println("array:" + array);
}
}
24. Hashtable
/*
* 1:Hashtable和HashMap的区别?
* Hashtable:线程安全，效率低。不允许null键和null值
* HashMap:线程不安全，效率高。允许null键和null值
*
* 2:List,Set,Map等接口是否都继承子Map接口?
* List，Set不是继承自Map接口，它们继承自Collection接口
* Map接口本身就是一个顶层接口
*/
public class HashtableDemo {
public static void main(String[] args) {
// HashMap<String, String> hm = new HashMap<String, String>();
Hashtable<String, String> hm = new Hashtable<String, String>();
hm.put("it001", "hello");
// hm.put(null, "world"); //NullPointerException
// hm.put("java", null); // NullPointerException
System.out.println(hm);
}
}
25. Collections
|
|
/*
* Collections:是针对集合进行操作的工具类，都是静态方法。
*
* 面试题：
* Collection和Collections的区别?
* Collection:是单列集合的顶层接口，有子接口List和Set。
* Collections:是针对集合操作的工具类，有对集合进行排序和二分查找的方法
*
* 要知道的方法
* public static <tT> void sort(List<T> list)：排序 默认情况下是自然顺序。
* public static <T> int binarySearch(List<?> list,T key):二分查找
* public static <T> T max(Collection<?> coll):最大值
* public static void reverse(List<?> list):反转
* public static void shuffle(List<?> list):随机置换
*/
public class CollectionsDemo {
public static void main(String[] args) {
// 创建集合对象
List<Integer> list = new ArrayList<Integer>();
// 添加元素
list.add(30);
list.add(20);
list.add(50);
list.add(10);
list.add(40);
System.out.println("list:" + list);
// public static <T> void sort(List<T> list)：排序 默认情况下是自然顺序。
// Collections.sort(list);
// System.out.println("list:" + list);
// [10, 20, 30, 40, 50]
// public static <T> int binarySearch(List<?> list,T key):二分查找
// System.out
// .println("binarySearch:" + Collections.binarySearch(list, 30));
// System.out.println("binarySearch:"
// + Collections.binarySearch(list, 300));
// public static <T> T max(Collection<?> coll):最大值
// System.out.println("max:"+Collections.max(list));
// public static void reverse(List<?> list):反转
// Collections.reverse(list);
// System.out.println("list:" + list);
//public static void shuffle(List<?> list):随机置换
Collections.shuffle(list);
System.out.println("list:" + list);
}
}
|
|
/*
* Collections可以针对ArrayList存储基本包装类的元素排序，存储自定义对象可不可以排序呢?
*/
public class CollectionsDemo {
public static void main(String[] args) {
// 创建集合对象
List<Student> list = new ArrayList<Student>();
// 创建学生对象
Student s1 = new Student("林青霞", 27);
Student s2 = new Student("风清扬", 30);
Student s3 = new Student("刘晓曲", 28);
Student s4 = new Student("武鑫", 29);
Student s5 = new Student("林青霞", 27);
// 添加元素对象
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
list.add(s5);
// 排序
// 自然排序
// Collections.sort(list);
// 比较器排序
// 如果同时有自然排序和比较器排序，以比较器排序为主
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
int num = s2.getAge() - s1.getAge();
int num2 = num == 0 ? s1.getName().compareTo(s2.getName())
: num;
return num2;
}
});
// 遍历集合
for (Student s : list) {
System.out.println(s.getName() + "---" + s.getAge());
}
}
}
|
|
/*
* 模拟斗地主洗牌和发牌
*
* 分析：
* A:创建一个牌盒
* B:装牌
* C:洗牌
* D:发牌
* E:看牌
*/
public class PokerDemo {
public static void main(String[] args) {
// 创建一个牌盒
ArrayList<String> array = new ArrayList<String>();
// 装牌
// 黑桃A,黑桃2,黑桃3,...黑桃K
// 红桃A,...
// 梅花A,...
// 方块A,...
// 定义一个花色数组
String[] colors = { "♠", "♥", "♣", "♦" };
// 定义一个点数数组
String[] numbers = { "A", "2", "3", "4", "5", "6", "7", "8", "9", "10",
"J", "Q", "K" };
// 装牌
for (String color : colors) {
for (String number : numbers) {
array.add(color.concat(number));
}
}
array.add("小王");
array.add("大王");
// 洗牌
Collections.shuffle(array);
// System.out.println("array:" + array);
// 发牌
ArrayList<String> fengQingYang = new ArrayList<String>();
ArrayList<String> linQingXia = new ArrayList<String>();
ArrayList<String> liuYi = new ArrayList<String>();
ArrayList<String> diPai = new ArrayList<String>();
for (int x = 0; x < array.size(); x++) {
if (x >= array.size() - 3) {
diPai.add(array.get(x));
} else if (x % 3 == 0) {
fengQingYang.add(array.get(x));
} else if (x % 3 == 1) {
linQingXia.add(array.get(x));
} else if (x % 3 == 2) {
liuYi.add(array.get(x));
}
}
// 看牌
lookPoker("风清扬", fengQingYang);
lookPoker("林青霞", linQingXia);
lookPoker("刘意", liuYi);
lookPoker("底牌", diPai);
}
public static void lookPoker(String name, ArrayList<String> array) {
System.out.print(name + "的牌是：");
for (String s : array) {
System.out.print(s + " ");
}
System.out.println();
}
}
|
|
/*
* 思路：
* A:创建一个HashMap集合
* B:创建一个ArrayList集合
* C:创建花色数组和点数数组
* D:从0开始往HashMap里面存储编号，并存储对应的牌
* 同时往ArrayList里面存储编号即可。
* E:洗牌(洗的是编号)
* F:发牌(发的也是编号，为了保证编号是排序的，就创建TreeSet集合接收)
* G:看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌)
*/
public class PokerDemo {
public static void main(String[] args) {
// 创建一个HashMap集合
HashMap<Integer, String> hm = new HashMap<Integer, String>();
// 创建一个ArrayList集合
ArrayList<Integer> array = new ArrayList<Integer>();
// 创建花色数组和点数数组
// 定义一个花色数组
String[] colors = { "♠", "♥", "♣", "♦" };
// 定义一个点数数组
String[] numbers = { "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q",
"K", "A", "2", };
// 从0开始往HashMap里面存储编号，并存储对应的牌,同时往ArrayList里面存储编号即可。
int index = 0;
for (String number : numbers) {
for (String color : colors) {
String poker = color.concat(number);
hm.put(index, poker);
array.add(index);
index++;
}
}
hm.put(index, "小王");
array.add(index);
index++;
hm.put(index, "大王");
array.add(index);
// 洗牌(洗的是编号)
Collections.shuffle(array);
// 发牌(发的也是编号，为了保证编号是排序的，就创建TreeSet集合接收)
TreeSet<Integer> fengQingYang = new TreeSet<Integer>();
TreeSet<Integer> linQingXia = new TreeSet<Integer>();
TreeSet<Integer> liuYi = new TreeSet<Integer>();
TreeSet<Integer> diPai = new TreeSet<Integer>();
for (int x = 0; x < array.size(); x++) {
if (x >= array.size() - 3) {
diPai.add(array.get(x));
} else if (x % 3 == 0) {
fengQingYang.add(array.get(x));
} else if (x % 3 == 1) {
linQingXia.add(array.get(x));
} else if (x % 3 == 2) {
liuYi.add(array.get(x));
}
}
// 看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌)
lookPoker("风清扬", fengQingYang, hm);
lookPoker("林青霞", linQingXia, hm);
lookPoker("刘意", liuYi, hm);
lookPoker("底牌", diPai, hm);
}
// 写看牌的功能
public static void lookPoker(String name, TreeSet<Integer> ts,
HashMap<Integer, String> hm) {
System.out.print(name + "的牌是：");
for (Integer key : ts) {
String value = hm.get(key);
System.out.print(value + " ");
}
System.out.println();
}
}
|
|
1887
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
