目录
数组的长度是不可变的，集合的长度是可变的。
数组可以存基本数据类型和引用数据类型。
集合只能存引用数据类型。如果要存基本数据类型，需要存对应的包装类。
1.Collection
Collection 是单例集合的顶层接口，它表示一组对象，这些对象也称为 Collection 的元素。
JDK 不提供此接口的任何直接实现，它提供更具体的子接口（如 Set 和 List）实现。
1.1 常用成员方法
package com.qdu.mycollectiondemo1;
import java.util.ArrayList;
import java.util.Collection;
public class MyCollectonDemo2 {
public static void main(String[] args) {
Collection<String> collection = new ArrayList<>();
// boolean add(E e) 添加元素
collection.add("aaa");
collection.add("bbb");
collection.add("ccc");
collection.add("dddd");
System.out.println(collection); // [aaa, bbb, ccc, dddd]
// boolean remove(Object o) 从集合中移除指定的元素，若删除成功，则返回true；若删除失败，则返回false
boolean result1 = collection.remove("aaa");
boolean result2 = collection.remove("ddd");
System.out.println(result1); // true
System.out.println(result2); // false
System.out.println(collection); // [bbb, ccc, dddd]
}
}
package com.qdu.mycollectiondemo1;
import java.util.ArrayList;
import java.util.Collection;
public class MyCollectonDemo2 {
public static void main(String[] args) {
Collection<String> collection = new ArrayList<>();
// boolean add(E e) 添加元素
collection.add("aaa");
collection.add("bbb");
collection.add("ccc");
collection.add("dddd");
System.out.println(collection); // [aaa, bbb, ccc, dddd]
// boolean removeIf(Object o) 根据条件进行删除
// removeIf 底层会遍历集合，得到集合中的每一个元素，把每一个元素都带到lambda表达式中去判断一下
// 如果返回的是true，则删除；如果返回的是false，则保留。
collection.removeIf(
(String s)->{
return s.length() == 3;
}
);
System.out.println(collection); // [dddd]
}
}
package com.qdu.mycollectiondemo1;
import java.util.ArrayList;
import java.util.Collection;
public class MyCollectonDemo2 {
public static void main(String[] args) {
Collection<String> collection = new ArrayList<>();
// boolean add(E e) 添加元素
collection.add("aaa");
collection.add("bbb");
collection.add("ccc");
collection.add("dddd");
System.out.println(collection); // [aaa, bbb, ccc, dddd]
// int size() 集合的长度，也就是集合中元素的个数
int size = collection.size();
System.out.println(size); // 4
// boolean contains(Object o) 判断集合中是否存在指定的元素
boolean result1 = collection.contains("a");
System.out.println(result1); // false
boolean result2 = collection.contains("aaa");
System.out.println(result2); // true
// boolean isEmpty() 判断集合是否为空
boolean result = collection.isEmpty();
System.out.println(result); // false
// void clear() 清空集合，就是将集合中所有的元素全部删除
collection.clear();
System.out.println(collection); // []
// boolean isEmpty() 判断集合是否为空
result = collection.isEmpty();
System.out.println(result); // true
}
}
1.2 迭代器
Iterator：迭代器，集合的专用遍历方式。
Iterator<E> iterator()：返回集合中的迭代器对象，该迭代器对象默认指向当前集合的 0 索引。
boolean hasNext()：判断当前位置是否有元素可以被取出。
E next()：获取当前位置的元素，将迭代器对象移向下一个索引位置。
package com.qdu.mycollectiondemo1;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class MyCollectonDemo3 {
public static void main(String[] args) {
Collection<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
// 获得迭代器的对象，迭代器对象一旦被创建出来，默认指向集合的0索引处
Iterator<String> it = list.iterator();
while(it.hasNext()){ // 当前位置是否有元素可以被取出
System.out.println(it.next()); // 取出当前位置的元素，将迭代器往后移动一个索引的位置
}
}
}
示例：创建一个集合 a b b c d，使用循环遍历这个集合，判断当前获取到的元素是否为 b，如果是就删除。
package com.qdu.mycollectiondemo1;
import java.util.ArrayList;
public class MyCollectonDemo4 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("b");
list.add("c");
list.add("d");
for (int i = 0; i < list.size(); i++) {
String s = list.get(i);
if("b".equals(s)){
list.remove(i);
i--;
}
}
System.out.println(list); // [a, c, d]
}
}
package com.qdu.mycollectiondemo1;
import java.util.ArrayList;
import java.util.Iterator;
public class MyCollectonDemo5 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("b");
list.add("c");
list.add("d");
Iterator<String> it = list.iterator();
while(it.hasNext()){
String s = it.next();
if("b".equals(s)){
it.remove(); // 指向谁，那么此时就删除谁
}
}
System.out.println(list); // [a, c, d]
}
}
1.3 增强 for 循环
增强 for：简化数组和 Collection 集合的遍历。
它是 JDK5 之后出现的，其内部原理是一个 Iterator 迭代器。
只有实现 Iterable 接口的类才可以使用迭代器和增强 for。
格式：for(元素数据类型 变量名 : 数组或者Collection集合) { }
list.for 可以快速生成增强 for 循环。
package com.qdu.mycollectiondemo1;
import java.util.ArrayList;
public class MyCollectonDemo6 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
list.add("f");
// 1.数据类型一定是集合或者数组中元素的类型
// 2.str仅仅是一个变量名而已，在循环的过程中依次表示集合或者数组中的每一个元素
// 3.list就是要遍历的集合或者数组
for(String str : list){
System.out.println(str);
}
}
}
package com.qdu.mycollectiondemo1;
import java.util.ArrayList;
public class MyCollectonDemo7 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
for(String str : list){
str = "q";
System.out.println(str); // q
}
System.out.println(list); // [a, b, c, d]
}
}
2.List
List 集合特点：
- 有序：存储和取出的元素顺序一致
- 有索引：可以通过索引操作元素
- 可重复：存储的元素可以重复
package com.qdu.mylistdemo1;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class MyListDemo1 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
Iterator<String> it = list.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s);
}
for (String s : list) {
System.out.println(s);
}
}
}
List 特有方法：
package com.qdu.mylistdemo1;
import java.util.ArrayList;
import java.util.List;
public class MyListDemo2 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
// void add(int index, E element) 在集合中的指定位置插入指定的元素，原来位置上的元素往后挪一个索引
list.add(0,"qqq");
System.out.println(list); // [qqq, aaa, bbb, ccc]
// E remove(int index) 删除指定索引处的元素，返回被删除的元素
String s = list.remove(0);
System.out.println(s); // qqq
System.out.println(list); // [aaa, bbb, ccc]
// E set(int index, E element) 修改指定索引处的元素，返回被修改的元素，被替换的那个元素在集合中就不存在了
String result = list.set(0, "qqq");
System.out.println(result); // aaa
System.out.println(list); // [qqq, bbb, ccc]
// E get(int index) 返回指定索引处的元素
s = list.get(0);
System.out.println(s); // qqq
}
}
3.LinkedList
List 集合常用子类：ArrayList, LinkedList
- ArrayList：底层数据结构是数组，查询快，增删慢
- LinkedList：底层数据结构是链表，查询慢，增删快
package com.qdu.mylistdemo1;
import java.util.Iterator;
import java.util.LinkedList;
public class MyLinkedListDemo3 {
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("-------------------------");
Iterator<String> it = list.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s);
}
System.out.println("--------------------------");
for (String s : list) {
System.out.println(s);
}
}
}
LinkedList 特有方法：
package com.qdu.mylistdemo1;
import java.util.LinkedList;
public class MyLinkedListDemo4 {
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
// public void addFirst(E e) 在该列表开头插入指定的元素
list.addFirst("qqq");
System.out.println(list); // [qqq, aaa, bbb, ccc]
// public void addLast(E e) 将指定的元素追加到此列表的末尾
list.addLast("www");
System.out.println(list); // [qqq, aaa, bbb, ccc, www]
// public E getFirst() 返回此列表中的第一个元素
String first = list.getFirst();
System.out.println(first); // qqq
// public E getLast() 返回此列表中的最后一个元素
String last = list.getLast();
System.out.println(last); // www
// public E removeFirst() 从此列表中删除并返回第一个元素
first = list.removeFirst();
System.out.println(first); // qqq
// public E removeLast() 从此列表中删除并返回最后一个元素
last = list.removeLast();
System.out.println(last); // www
System.out.println(list); // [aaa, bbb, ccc]
}
}
4.泛型
泛型：是 JDK5 中引入的特性，它提供了编译时类型安全检测机制。
泛型的好处：把运行期的问题提前到了编译期；避免了强制类型转换。
package com.qdu.genericitysummarize;
import java.util.ArrayList;
import java.util.Iterator;
public class GenericitySummarize {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add(123);
Iterator it = list.iterator();
while(it.hasNext()){
String next = (String) it.next(); // 不写泛型的弊端
int len = next.length();
System.out.println(len);
}
}
}
4.1 泛型类
如果一个类的后面有 <E>，表示这个类是一个泛型类。
创建泛型类的对象时，必须要给这个泛型确定具体的数据类型。
泛型的定义格式：
<类型>：指定一种类型的格式。尖括号里面可以任意书写，按照变量的定义规则即可。一般只写一个字母，比如<E><T><Q><M>。<类型1, 类型2...>：指定多种类型的格式，多种类型之间用逗号隔开，比如<E,T><Q,M><K,V>。
泛型类的定义格式：修饰符 class 类名<类型> { }
package com.qdu.genericityclass;
public class Box<E> {
private E element;
public E getElement() {
return element;
}
public void setElement(E element) {
this.element = element;
}
}
package com.qdu.genericityclass;
public class MyGenericityClass {
public static void main(String[] args) {
Box<String> box1 = new Box<>();
box1.setElement("hello");
String element1 = box1.getElement();
System.out.println(element1);
Box<Integer> box2 = new Box<>();
box2.setElement(19);
Integer element2 = box2.getElement();
System.out.println(element2);
}
}
4.2 泛型方法
如果泛型定义在方法声明上，表示这个方法是一个泛型方法。
package com.qdu.genericitymethod;
import java.util.ArrayList;
import java.util.Arrays;
public class GenericityMethod1 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("hello");
list.add("hi");
list.add("world");
// Object[] toArray() 将list集合转成一个数组并返回，如果是空参的，那么返回的数组类型为Object类型的
Object[] objects = list.toArray();
System.out.println(Arrays.toString(objects)); // [hello, hi, world]
// <T> T[] toArray(T[] a) 将list集合转成一个数组并返回，返回的数组类型是指定的数组类型
String[] strings = list.toArray(new String[list.size()]);
System.out.println(Arrays.toString(strings)); // [hello, hi, world]
}
}
泛型方法的定义格式：修饰符 <类型> 返回值类型 方法名(类型 变量名) { }
示例：定义一个泛型方法，传递一个集合和四个元素，将元素添加到集合中并返回。
package com.qdu.genericitymethod;
import java.util.ArrayList;
public class GenericityMethod2 {
public static void main(String[] args) {
ArrayList<String> list1 = addElement(new ArrayList<String>(), "a", "b", "c", "d");
System.out.println(list1); // [a, b, c, d]
ArrayList<Integer> list2 = addElement(new ArrayList<Integer>(), 1, 2, 3, 4);
System.out.println(list2); // [1, 2, 3, 4]
}
public static <T> ArrayList<T> addElement(ArrayList<T> list , T t1 ,T t2 ,T t3 ,T t4) {
list.add(t1);
list.add(t2);
list.add(t3);
list.add(t4);
return list;
}
}
4.3 泛型接口
如果泛型定义在接口后面，表示这个接口是一个泛型接口。
泛型接口的使用方式：
- 实现类也不给泛型。
- 实现类确定具体的数据类型。
泛型接口的定义格式：修饰符 interface 接口名<类型> { }
package com.qdu.genericityinterface;
public class GenericityInterface {
public static void main(String[] args) {
GenericityImpl1<String> genericity = new GenericityImpl1<>();
genericity.method("hello");
GenericityImpl2 genericityImpl2 = new GenericityImpl2();
genericityImpl2.method(19);
}
}
interface Genericity<E> {
public abstract void method(E e);
}
class GenericityImpl2 implements Genericity<Integer> {
@Override
public void method(Integer integer) {
System.out.println(integer);
}
}
// Shift + F6
class GenericityImpl1<E> implements Genericity<E> {
@Override
public void method(E e) {
System.out.println(e);
}
}
4.4 类型通配符
类型通配符：<?>
ArrayList<?>：表示元素类型未知的 ArrayList，它的元素可以匹配任何的类型。但是并不能把元素添加到 ArrayList 中了，获取出来的也是父类类型。
类型通配符上限：<? extends 类型>
ArrayList<? extends Number>：它表示的类型是 Number 或者其子类型。
类型通配符下限：<? super 类型>
ArrayList<? super Number>：它表示的类型是 Number 或者其父类型。
package com.qdu.genericityglobbing;
import java.util.ArrayList;
public class genericityglobbing1 {
public static void main(String[] args) {
ArrayList<Integer> list1 = new ArrayList<>();
ArrayList<String> list2 = new ArrayList<>();
printList(list1);
printList(list2);
}
private static void printList(ArrayList<?> list) {
}
}
package com.qdu.genericityglobbing;
import java.util.ArrayList;
public class genericityglobbing1 {
public static void main(String[] args) {
ArrayList<Integer> list1 = new ArrayList<>();
ArrayList<Number> list2 = new ArrayList<>();
ArrayList<Object> list3 = new ArrayList<>();
method1(list1);
method1(list2);
// method1(list3);
// method2(list1);
method2(list2);
method2(list3);
}
// 传递进来的集合可以是Number类型，也可以是Number所有的子类类型
private static void method1(ArrayList<? extends Number> list) {
}
// 传递进来的集合可以是Number类型，也可以是Number所有的父类类型
private static void method2(ArrayList<? super Number> list) {
}
}