16 API-集合(List的子类(ArrayList_Vector_LinkedList,集合嵌套遍历),JDK5新特性(泛型,增强for循环,静态导入,可变参数)

1:List的子类(掌握)

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

(2)ArrayList

A:没有特有功能需要学习
B:案例
a:ArrayList存储字符串并遍历
b:ArrayList存储自定义对象并遍历

(3)Vector

A:有特有功能
a:添加
public void addElement(E obj) -- add()
b:获取
public E elementAt(int index) -- get()

public Enumeration<E> elements()--  iterator()

* boolean hasMoreElements() ---- hasNext()
 * Object nextElement() -------next()

B:案例
a:Vector存储字符串并遍历

b:Vector存储自定义对象并遍历

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);
}
}
}

(4)LinkedList

A:有特有功能
a:添加
addFirst()
addLast()
b:删除
removeFirst()
removeLast()
c:获取
getFirst()
getLast()
B:案例
a:LinkedList存储字符串并遍历
b:LinkedList存储自定义对象并遍历
(5)案例：

A:去除集合中的多个字符串的重复元素

如果字符串的内容相同，即为重复元素

两种思路

1.创建一个新集合 ，往里面添加旧集合元素，添加时候判定是否equals， 加或者不加

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

/*
 * 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);
}
}
}

2.（如果不创建新集合）选择排序内外循环比较equals

如果相同 就删除remove这个，同时内循环自增要y--复位（如果同时N个重复会漏算）

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

/*
 * 需求：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);
}
}
}

B:去除集合中的多个自定义对象的重复元素

如果自定义对象的成员变量值都相同，即为重复元素

学生类略

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

/*
 * 需求：去除集合中自定义对象的重复值(对象的成员变量值都相同)
 * 
 * 我们按照和字符串一样的操作，发现出问题了。
 * 为什么呢?
 * 我们必须思考哪里会出问题?
 * 通过简单的分析，我们知道问题出现在了判断上。
 * 而这个判断功能是集合自己提供的，所以我们如果想很清楚的知道它是如何判断的，就应该去看源码。
 * 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());
}
}
}

C:用LinkedList模拟一个栈数据结构的集合类，并测试。

你要定义一个集合类，只不过内部可以使用LinkedList来实现。

思路：栈数据结构特点先进后出，利用LinkedList的特有方法addFirst()及removeFirst()来体现。

第一步 自定义栈集合MyStack

import java.util.LinkedList;

/**
 * 自定义的栈集合
 * 
 * @author 风清扬
 * @version V1.0
 */
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(); 如果是这个都是java 每次都是第一个 没有弹栈
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());
}
}
}

2:泛型(掌握)

(1)泛型概述
是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。
(2)格式：
<数据类型>        <T>等

注意：该数据类型只能是引用类型。

(3)好处：
A:把运行时期的问题提前到了编译期间
B:避免了强制类型转换
C:优化了程序设计，解决了黄色警告线问题，让程序更安全
(4)泛型的前世今生
A:泛型的由来
Object类型作为任意类型的时候，在向下转型的时候，会隐含一个转型问题

B:泛型类

•把泛型定义在类上•格式:public class 类名<泛型类型1,…>•注意:泛型类型必须是引用类型

C:泛型方法

•把泛型定义在方法上•格式:public <泛型类型> 返回类型 方法名(泛型类型 .)

D:泛型接口  如果类，接口，抽象类后面跟的有<E>就说要使用泛型。一般来说就是在集合中使用

•把泛型定义在接口上•格式:public  interface 接口名<泛型类型1…>

E:泛型高级通配符

?      任意类型，如果没有明确，那么就是Object以及任意的Java类了

class Animal {
}

class Dog extends Animal {
}

class Cat extends Animal {
}

// 泛型如果明确的写的时候，前后必须一致
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及其子类

// ? extends E:向下限定，E及其子类
// Collection<? extends Animal> c9 = new ArrayList<Object>();//报错 Animal的父类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极其父类

// ? super E:向上限定，E极其父类
Collection<? super Animal> c13 = new ArrayList<Object>();
Collection<? super Animal> c14 = new ArrayList<Animal>();
// Collection<? super Animal> c15 = new ArrayList<Dog>();//报错只能Animal或者Animal的父类 向上限定了
// Collection<? super Animal> c16 = new ArrayList<Cat>();//报错只能Animal或者Animal的父类 向上限定了

(5)我们在哪里使用呢?

一般是在集合中使用。

3:增强for循环(掌握)

JDK5的新特性：自动拆装箱,泛型,增强for,静态导入,可变参数,枚举

(1)是for循环的一种

简化数组和Collection集合的遍历

public interface Iterable<T> 实现这个接口允许对象成为 "foreach" 语句的目标。

(2)格式：

*            for(元素数据类型 变量 : 数组或者Collection集合) {

*                   使用变量即可，该变量就是元素

*          }

(3)好处：
简化了数组和集合的遍历
(4)弊端
增强for循环的目标不能为null。建议在使用前，先判断是否为null。
 

4:静态导入(了解)

(1)可以导入到方法级别的导入
(2)格式：

import static 包名....类名.方法名;

import static java.lang.Math.abs;
import static java.lang.Math.pow;
import static java.lang.Math.max;

(3)注意事项：
A:方法必须是静态的
B:如果多个类下有同名的方法，就不好区分了，还得加上前缀。
所以一般我们并不使用静态导入，但是一定要能够看懂。

5:可变参数(掌握)

(1)如果我们在写方法的时候，参数个数不明确，就应该定义可变参数。
(2)格式：
修饰符 返回值类型 方法名(数据类型... 变量) {}

注意：
A:该变量其实是一个数组名
B:如果一个方法有多个参数，并且有可变参数，可变参数必须在最后
(3)Arrays工具类的一个方法

asList()把数组转成集合。

public static <T> List<T> asList(T... a)  

List<String> list = Arrays.asList("hello", "world", "java");

注意：这个集合的长度不能改变。

package cn.itcast_03;

import java.util.Arrays;
import java.util.List;

/*
 * public static <T> List<T> asList(T... a):把数组转成集合
 * 
 * 注意事项：
 * 虽然可以把数组转成集合，但是集合的长度不能改变。
 */
public class ArraysDemo {
public static void main(String[] args) {
// 定义一个数组
// String[] strArray = { "hello", "world", "java" };
// List<String> list = Arrays.asList(strArray);

List<String> list = Arrays.asList("hello", "world", "java");
// UnsupportedOperationException
// list.add("javaee");
// UnsupportedOperationException
// list.remove(1);
list.set(1, "javaee");

for (String s : list) {
System.out.println(s);
}
}
}

6:练习(掌握)

A:集合的嵌套遍历

1.学生类（略）

import java.util.ArrayList;

/*
 * 集合的嵌套遍历
 * 需求：
 * 我们班有学生，每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList<Student>
 * 但是呢，我们旁边是不是还有班级，每个班级是不是也是一个ArrayList<Student>。
 * 而我现在有多个ArrayList<Student>。也要用集合存储，怎么办呢?
 * 就是这个样子的：ArrayList<ArrayList<Student>>
 */
public class ArrayListDemo {
public static void main(String[] args) {
// 创建大集合
ArrayList<ArrayList<Student>> bigArrayList = new ArrayList<ArrayList<Student>>();

// 创建第一个班级的学生集合
ArrayList<Student> firstArrayList = new ArrayList<Student>();
// 创建学生
Student s1 = new Student("唐僧", 30);
Student s2 = new Student("孙悟空", 29);
Student s3 = new Student("猪八戒", 28);
Student s4 = new Student("沙僧", 27);
Student s5 = new Student("白龙马", 26);
// 学生进班
firstArrayList.add(s1);
firstArrayList.add(s2);
firstArrayList.add(s3);
firstArrayList.add(s4);
firstArrayList.add(s5);
// 把第一个班级存储到学生系统中
bigArrayList.add(firstArrayList);

// 创建第二个班级的学生集合
ArrayList<Student> secondArrayList = new ArrayList<Student>();
// 创建学生
Student s11 = new Student("诸葛亮", 30);
Student s22 = new Student("司马懿", 28);
Student s33 = new Student("周瑜", 26);
// 学生进班
secondArrayList.add(s11);
secondArrayList.add(s22);
secondArrayList.add(s33);
// 把第二个班级存储到学生系统中
bigArrayList.add(secondArrayList);

// 创建第三个班级的学生集合
ArrayList<Student> thirdArrayList = new ArrayList<Student>();
// 创建学生
Student s111 = new Student("宋江", 40);
Student s222 = new Student("吴用", 35);
Student s333 = new Student("高俅", 30);
Student s444 = new Student("李师师", 22);
// 学生进班
thirdArrayList.add(s111);
thirdArrayList.add(s222);
thirdArrayList.add(s333);
thirdArrayList.add(s444);
// 把第三个班级存储到学生系统中
bigArrayList.add(thirdArrayList);

// 遍历集合
for (ArrayList<Student> array : bigArrayList) {
for (Student s : array) {
System.out.println(s.getName() + "---" + s.getAge());
}
}
}
}

B:产生10个1-20之间的随机数，要求随机数不能重复

import java.util.ArrayList;
import java.util.Random;

/*
 * 获取10个1-20之间的随机数，要求不能重复
 * 
 * 用数组实现，但是数组的长度是固定的，长度不好确定。
 * 所以我们使用集合实现。
 * 
 * 分析：
 * A:创建产生随机数的对象
 * B:创建一个存储随机数的集合。
 * C:定义一个统计变量。从0开始。
 * D:判断统计遍历是否小于10
 * 是:先产生一个随机数，判断该随机数在集合中是否存在。
 * 如果不存在:就添加，统计变量++。
 * 如果存在:就不搭理它。
 * 否：不搭理它
 * E:遍历集合
 */
public class RandomDemo {
public static void main(String[] args) {
// 创建产生随机数的对象
Random r = new Random();

// 创建一个存储随机数的集合。
ArrayList<Integer> array = new ArrayList<Integer>();

// 定义一个统计变量。从0开始。
int count = 0;

// 判断统计遍历是否小于10
while (count < 10) {
//先产生一个随机数
int number = r.nextInt(20) + 1;

//判断该随机数在集合中是否存在。
if(!array.contains(number)){
//如果不存在:就添加，统计变量++。
array.add(number);
count++;
}
}

//遍历集合
for(Integer i : array){
System.out.println(i);
}
}
}

C:键盘录入多个数据，以0结束，并在控制台输出最大值

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

/*
 * 键盘录入多个数据，以0结束，要求在控制台输出这多个数据中的最大值
 * 
 * 分析：
 * A:创建键盘录入数据对象
 * B:键盘录入多个数据,我们不知道多少个，所以用集合存储
 * C:以0结束,这个简单，只要键盘录入的数据是0，我就不继续录入数据了
 * D:把集合转成数组
 * E:对数组排序
 * F:获取该数组中的最大索引的值
 */
public class ArrayListDemo {
public static void main(String[] args) {
// 创建键盘录入数据对象
Scanner sc = new Scanner(System.in);

// 键盘录入多个数据,我们不知道多少个，所以用集合存储
ArrayList<Integer> array = new ArrayList<Integer>();

// 以0结束,这个简单，只要键盘录入的数据是0，我就不继续录入数据了
while (true) {
System.out.println("请输入数据：");
int number = sc.nextInt();
if (number != 0) {
array.add(number);
} else {
break;
}
}

// 把集合转成数组
// public <T> T[] toArray(T[] a)
Integer[] i = new Integer[array.size()];
// Integer[] ii = array.toArray(i);
array.toArray(i);
// System.out.println(i);
// System.out.println(ii);

// 对数组排序
// public static void sort(Object[] a)
Arrays.sort(i);

// 获取该数组中的最大索引的值
System.out.println("数组是：" + arrayToString(i) + "最大值是:"
+ i[i.length - 1]);
}

public static String arrayToString(Integer[] i) {
StringBuilder sb = new StringBuilder();

sb.append("[");
for (int x = 0; x < i.length; x++) {
if (x == i.length - 1) {
sb.append(i[x]);
} else {
sb.append(i[x]).append(", ");
}
}
sb.append("]");

return sb.toString();
}
}

7:要掌握的代码
集合存储元素，加入泛型，并可以使用增强for遍历。