集合_2

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()

B:案例

a:Vector存储字符串并遍历

import java.util.Enumeration;import java.util.Vector;/* * 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);}}}

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

(4)LinkedList

A:有特有功能

a:添加

addFirst()

addLast()

b:删除

removeFirst()

removeLast()

c:获取

getFirst()

getLast()

import java.util.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);}}

B:案例

a:LinkedList存储字符串并遍历

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

(5)案例：

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

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

test：

用新的集合来装各个不重复的元素

import java.util.ArrayList;public class class4 {public static void main(String[] args) {ArrayList list = new ArrayList();list.add("111");list.add("222");list.add("333");list.add("111");list.add("444");list.add("222");System.out.println("list:" + list);ArrayList list2 = new ArrayList();//Iterator it = list.iterator();//while (it.hasNext()) {//String s = (String) it.next();//if (!list2.contains(s)) {//list2.add(s);//}////}// 循环提取list的元素for (int i = 0; i < list.size(); i++) {// 如果list2不包含提取到的元素，就添加进list2if (!list2.contains(list.get(i))) {list2.add(list.get(i));}}System.out.println("list2:" + list2);}}

输出：

list:[111, 222, 333, 111, 444, 222]

list2:[111, 222, 333, 444]

Test2：

不能新建集合，使用原集合

/** * 去除集合中的重复元素，不能新建集合 */import java.util.ArrayList;public class class4 {public static void main(String[] args) {ArrayList list = new ArrayList();list.add("111");list.add("222");list.add("333");list.add("111");list.add("111");list.add("111");list.add("444");list.add("222");list.add("111");list.add("444");System.out.println("list:" + list);// 双层循环实现for (int i = 0; i < list.size(); i++) {// 外层逐个提取元素，内层为外层元素逐一取比对的元素// 由于不能自身对比会误判，所以j=I+1for (int j = i + 1; j < list.size(); j++) {// 如果对比相同，则把靠后面的元素删除if (list.get(i) == list.get(j)) {list.remove(j);//由于有连续重复的元素，删除元素后继续搜索会漏掉一个//所以需要回退一部继续判断j--;}}}System.out.println("new list:" + list);}}

输出：

list:[111, 222, 333, 111, 111, 111, 444, 222, 111, 444]

new list:[111, 222, 333, 444]

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

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

Test:

import java.util.ArrayList;public class Test5 {public static void main(String[] args) {ArrayList list = new ArrayList();list.add(new Student("张三", 12));list.add(new Student("李四", 13));list.add(new Student("王五", 14));list.add(new Student("张三", 13));list.add(new Student("李四", 13));list.add(new Student("王五", 14));list.add(new Student("张三", 12));list.add(new Student("李四", 13));list.add(new Student("张三", 12));// 双层循环实现// 外循环逐个提取元素for (int i = 0; i < list.size(); i++) {// 内循环提取待比较的各个元素for (int j = i + 1; j < list.size(); j++) {// 转换成 原始数据类型Student s = (Student) list.get(i);Student s2 = (Student) list.get(j);// 如果两个引用类型的两个值（name，age）都相同则判定相同，删除靠后的元素if (s.getName() == s2.getName() && s.getAge() == s2.getAge()) {list.remove(j);j--;}}}// 遍历集合for (int i = 0; i < list.size(); i++) {Student s = (Student) list.get(i);System.out.println(s.getName() + "\t" + s.getAge());}}}

输出：

张三12

李四13

王五14

张三13

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

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

2:泛型(掌握)

(1)泛型概述

是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。

(2)格式：

<数据类型>

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

(3)好处：

A:把运行时期的问题提前到了编译期间

B:避免了强制类型转换

C:优化了程序设计，解决了黄色警告线问题，让程序更安全

(4)泛型的前世今生

A:泛型的由来

Object类型作为任意类型的时候，在向下转型的时候，会隐含一个转型问题

B:泛型类

C:泛型方法

D:泛型接口

E:泛型高级通配符

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

? extends E  向下限定，只能使用E及其子类 

? super E   向上限定，只能使用E及其父类

import java.util.ArrayList;import java.util.Collection;/* * 泛型高级(通配符) * ?:任意类型，如果没有明确，那么就是Object以及任意的Java类了 * ? extends E:向下限定，E及其子类 * ? super E:向上限定，E极其父类 */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>();}}class Animal {}class Dog extends Animal {}class Cat extends Animal {}

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

一般是在集合中使用。

3:增强for循环(掌握)

(1)是for循环的一种

(2)格式：

for(元素的数据类型 变量名 : 数组或者Collection集合的对象) {

使用该变量即可，该变量其实就是数组或者集合中的元素。

}

(3)好处：

简化了数组和集合的遍历

(4)弊端

增强for循环的目标不能为null。建议在使用前，先判断是否为null。

Test：

import java.util.ArrayList;import java.util.List;/* * 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("---------------");// 增强forfor (int x : arr) {System.out.println(x);}System.out.println("---------------");// 定义一个字符串数组String[] strArray = { "林青霞", "风清扬", "东方不败", "刘意" };// 增强forfor (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");// 增强forfor (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);}}

Test2:

三种方法遍历字符串集合

import java.util.ArrayList;import java.util.Iterator;/* * 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("------------------");// 普通forfor (int x = 0; x < array.size(); x++) {String s = array.get(x);System.out.println(s);}System.out.println("------------------");// 增强forfor (String s : array) {System.out.println(s);}}}

 

Test3：

三种方法遍历自定义类型集合

import java.util.ArrayList;import java.util.Iterator;/* * 需求：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("---------------");// 普通forfor (int x = 0; x < array.size(); x++) {Student s = array.get(x);System.out.println(s.getName() + "---" + s.getAge());}System.out.println("---------------");// 增强forfor (Student s : array) {System.out.println(s.getName() + "---" + s.getAge());}}}

4:静态导入(了解)

(1)可以导入到方法级别的导入

(2)格式：

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

(3)注意事项：

A:方法必须是静态的

B:如果多个类下有同名的方法，就不好区分了，还得加上前缀。

所以一般我们并不使用静态导入，但是一定要能够看懂。

Test：

/* * 静态导入： * 格式：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);}}

5:可变参数(掌握)

(1)如果我们在写方法的时候，参数个数不明确，就应该定义可变参数。

(2)格式：

修饰符 返回值类型 方法名(数据类型... 变量) {}

注意：

A:该变量其实是一个数组名

B:如果一个方法有多个参数，并且有可变参数，可变参数必须在最后

Test：

public class test6 {public static void main(String[] args) {System.out.println(sum(1, 2, 3, 4, 5, 6, 7, 8, 9));}public static int sum(int... n) {int sum = 0;for (int i : n) {sum += i;}return sum;}}

(3)Arrays工具类的一个方法

asList()把数组转成集合。

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

Test：

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:集合的嵌套遍历

Demo：

package cn.itcast_01;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());}}}}

Test：

package bao_01;import java.util.ArrayList;public class Test9 {public static void main(String[] args) {// 新建三个<Student>自定义对象集合ArrayList<Student> list1 = new ArrayList<>();ArrayList<Student> list2 = new ArrayList<>();ArrayList<Student> list3 = new ArrayList<>();// 新建一个储存集合的集合// 类型也应对应普通集合，<ArrayList<Student>>ArrayList<ArrayList<Student>> listS = new ArrayList<>();// Student集合添加元素list1.add(new Student("小一", 1));list1.add(new Student("小二", 2));list1.add(new Student("小三", 3));list2.add(new Student("小四", 4));list2.add(new Student("小五", 5));list2.add(new Student("小六", 6));list3.add(new Student("小七", 7));list3.add(new Student("小八", 8));list3.add(new Student("小九", 9));// ArrayList<Student>类型集合添加元素listS.add(list1);listS.add(list2);listS.add(list3);// for增强型循环方式实现遍历// 外循环从总集合中提取ArrayList<Student>类型的元素for (ArrayList<Student> arr : listS) {// 内循环提取Student类型元素for (Student s : arr) {System.out.println(s.getName() + "\t" + s.getAge());}System.out.println("++++++++++++++++++++");}// //普通for循环方法实现遍历// //外循环从总集合中提取元素// for (int i = 0; i < listS.size(); i++) {// //内循环从子集合中提取元素// for (int j = 0; j < listS.get(i).size(); j++) {// 将子集合中的元素转换为原始的Student类// Student s = (Student) listS.get(i).get(j);// System.out.println(s.getName() + "\t" + s.getAge());// }// System.out.println("+++++++++++++++++++++++");// }}}

输出：

小一1

小二2

小三3

+++++++++++++++++++++++

小四4

小五5

小六6

+++++++++++++++++++++++

小七7

小八8

小九9

+++++++++++++++++++++++

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

Demo：

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;// 判断统计遍历是否小于10while (count < 10) {//先产生一个随机数int number = r.nextInt(20) + 1;//判断该随机数在集合中是否存在。if(!array.contains(number)){//如果不存在:就添加，统计变量++。array.add(number);count++;}}//遍历集合for(Integer i : array){System.out.println(i);}}}

Test：

import java.util.ArrayList;import java.util.Random;public class Test7 {public static void main(String[] args) {// 新建整数集合ArrayList<Integer> list = new ArrayList<>();// 新建获取随机数对象Random m = new Random();int n = 0;// for (int i = 0; i < 100; i++) {// n=m.nextInt(20)+1;// System.out.println(n);// }// 当集合元素不到10个时循环while (list.size() < 10) {// 获取1-20的随机数n = m.nextInt(20) + 1;// 如果集合中不包含该元素就添加进去if (!list.contains(n)) {list.add(n);}}// 遍历集合for (int x : list) {System.out.println(x);}}}

输出：

6

11

7

9

16

14

5

12

15

19

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

Demo：

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

Test：

import java.util.ArrayList;import java.util.Scanner;public class Test8 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);ArrayList<Integer> list = new ArrayList<>();System.out.println("请开始输入数据，以数字0结束：");int n = sc.nextInt();// 当输入的数字不是0时则提示继续输入while (n != 0) {list.add(n);System.out.println("请输入下一个数据：");n = sc.nextInt();}System.out.println("输入结束。");System.out.println("输入的最大的数字为：" + Max(list));}/*** * 求Integer类型集合中的最大值 *  * @param list * @return */public static int Max(ArrayList<Integer> list) {int m = list.get(0);for (int x : list) {// 如果既定值小于遍历值则进行赋值if (m < x) {m = x;}}return m;}}

输出：

请开始输入数据，以数字0结束：

54

请输入下一个数据：

48

请输入下一个数据：

13

请输入下一个数据：

81

请输入下一个数据：

0

输入结束。

输入的最大的数字为：81

#如果直接输入0会报错，集合为空无法遍历#

7:要掌握的代码

集合存储元素，加入泛型，并可以使用增强for遍历。