Set接口和泛型
集合体系接口
数组不是动态的，一个数组一旦创建，它的容量就是固定的不能被修改。为了添加新的元素，需要创建一个容量更大的数组，并且将数据拷贝到新的数组中。 数组新增元素示例
package day19;
import java.util.Arrays;
public class Day1901 {
public static void main(String[] args) {
int[] arr = new int[5];
arr[0] = 0;
arr[1] = 1;
arr[2] = 2;
arr[3] = 3;
arr[4] = 4;
// arr[5] = 5;//java.lang.ArrayIndexOutOfBoundsException
int[] arr1 = Arrays.copyOf(arr, 6);
arr1[5] = 5;
System.out.println(arr1.length);//6
}
}
集合是动态的，集合允许动态的添加，删除元素。当元素的数量超过集合的容量时，集合会自动扩容。
java中有一系列的集合，它们有各自的用途。
Collection接口
Collection接口是Collection体系中最顶层的接口。一个Collection代表了一组对象，这些对象被称为元素。
集合只能保存对象，不能保存基本数据类型，可以使用包装类。Collection接口定义了所有集合必须实现的通用方
法。有些类型的集合允许重复的元素，有些则不允许。有些类型的集合是有序的，有些不是。java并没有提供
Collection接口的具体实现类，而是提供了它的子接口如Set和List的具体实现类。
Collection接口API 这里的E表示集合中的元素的类型
interface Collection<E> extends Iterable<E>
{
boolean add(E paramE);//添加一个元素
boolean remove(Object paramObject);//删除一个元素
int size();//获取集合中元素的数量
boolean isEmpty();//判断集合是否为空
void clear();//清空集合中的元素
boolean contains(Object paramObject);//判断集合中是否包含一个元素
Iterator<E> iterator();//获取此集合的一个迭代器，通过迭代器可以遍历集合中的元素
//还有很多方法
}
Collection接口的使用
package day19;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
public class Day1902 {
public static void main(String[] args) {
// 使用泛型参数String，表示这个集合中可以存放String类型的元素List接口
Collection<String> c = new HashSet<String>();
// 获取集合中元素的数量
System.out.println(c.size());
// 判断集合是否为空
System.out.println(c.isEmpty());
// 向集合中加入一个元素
c.add("张三");
// 获取集合中元素的数量
System.out.println(c.size());
// 判断集合是否为空
System.out.println(c.isEmpty());
c.add("李四");
c.add("王五");
c.add("马六");
System.out.println(c.size());// 4
// 判断集合中是否包含指定的元素
// contains方法会对集合中的每个元素依次调用equals方法来和contains方法的参数进行比较
// contains方法依赖于元素实现了equals方法
System.out.println(c.contains("李四"));// true
// 从集合中删除指定的对象
// remove方法会对集合中的每个元素依次调用equals方法来和remove方法的参数进行比较
// remove方法依赖于元素实现了equals方法
c.remove("李四");
// 由于Collection集合不记录元素的索引位置，必须使用迭代器来遍历集合
// 获取集合c的迭代器i
Iterator<String> i = c.iterator();
// hashNext方法用于判断迭代器中是否还有下一个元素
while (i.hasNext()) {
// next方法用于获取迭代器中的下一个元素
System.out.println(i.next());
} /
/ 所有的集合都有一个迭代器
// foreach可以应用于实现了Iterable接口的集合
// Collection接口继承于Iterable接口，因此Collection所有的子集合都可以获取迭代器
// foreach内部就是使用迭代器
for (String str : c) {
System.out.println(str);
}
}
}
List接口
Collection c = new HashSet();
// 获取集合中元素的数量
System.out.println(c.size());
// 判断集合是否为空
System.out.println(c.isEmpty());
// 向集合中加入一个元素
c.add(“张三”);
// 获取集合中元素的数量
System.out.println(c.size());
// 判断集合是否为空
System.out.println(c.isEmpty());
c.add(“李四”);
c.add(“王五”);
c.add(“马六”);
System.out.println(c.size());// 4
// 判断集合中是否包含指定的元素
// contains方法会对集合中的每个元素依次调用equals方法来和contains方法的参数进行比较
// contains方法依赖于元素实现了equals方法
System.out.println(c.contains(“李四”));// true
// 从集合中删除指定的对象
// remove方法会对集合中的每个元素依次调用equals方法来和remove方法的参数进行比较
// remove方法依赖于元素实现了equals方法
c.remove(“李四”);
// 由于Collection集合不记录元素的索引位置，必须使用迭代器来遍历集合
// 获取集合c的迭代器i
Iterator i = c.iterator();
// hashNext方法用于判断迭代器中是否还有下一个元素
while (i.hasNext()) {
// next方法用于获取迭代器中的下一个元素
System.out.println(i.next());
} /
/ 所有的集合都有一个迭代器
// foreach可以应用于实现了Iterable接口的集合
// Collection接口继承于Iterable接口，因此Collection所有的子集合都可以获取迭代器
// foreach内部就是使用迭代器
for (String str : c) {
System.out.println(str);
}
}
}
List接口
List接口继承于Collection接口，因此它拥有Collection接口的所有方法。List接口是一个有序列表，它保留元素的添
加顺序，并且允许将元素添加到集合中的指定位置。 List接口类似数组，只不过它是可以动态扩展。 List接口示意
图：
当添加一个新的元素时，可以使用void add(E paramE)方法将元素添加到List集合的末尾。 也可以使用void add(intparamInt, E paramE);方法将元素添加到指定的位置。这样原来在此位置的元素和后续的元素都会向下移动。 也可以使用set和get方法来修改和获取指定位置的元素。 List接口的方法，未列全。
interface List<E> extends Collection<E>
{
E get(int paramInt);//获取指定位置的元素
E set(int paramInt, E paramE);//替换指定位置的元素，返回旧元素
void add(int paramInt, E paramE);//方法将元素添加到指定的位置
E remove(int paramInt);//删除指定位置的元素
int indexOf(Object paramObject);//获取指定元素的位置
int lastIndexOf(Object paramObject);//获取指定原的位置，从后向前搜索
ListIterator<E> listIterator();//返回一个迭代器
List<E> subList(int paramInt1, int paramInt2);//返回子列表
}
List接口有两个实现类：ArrayList和LinkedList
ArrayList的使用：
ArrayList实现了List接口，它保存元素的添加顺序。ArrayList的内部实现是一个数组。
package day19;
import java.util.ArrayList;
import java.util.List;
public class Day1903 {
public static void main(String[] args) {
// 创建了一个ArrayList集合，可以保存Integer类型的对象
List<Integer> list = new ArrayList<Integer>();
list.add(2);
list.add(1);//自动装箱
list.add(3);
//向索引处1加入元素4
//原来所以处1的元素和后续的元素都会往后移动
list.add(1, 4);
//获取元素1的索引
System.out.println(list.indexOf(1));
//将索引处1的元素替换为5，此方法将返回旧元素
System.out.println(list.set(1, 5));
//将索引处1的元素删除，此方法将返回旧元素，后续的元素将会向前移动
list.remove(1);
//删除指定元素
list.remove(Integer.valueOf(2));
System.out.println("******************************");
//List集合保留插入元素的顺序，进行迭代时是按照插入元素的顺序
for (Integer i : list) {
System.out.println(i);
} S
ystem.out.println("******************************");
//由于List集合中的元素带有索引，因此可以使用for循环来遍历
for (int i = 0; i < list.size(); i++) {
//get方法用于获取指定索引处的元素
System.out.println(list.get(i));
}
}
}
ArrayList可以保存重复元素
package day19;
import java.util.ArrayList;
import java.util.List;
public class Day1904 {
public static void main(String[] args) {
//List可以保存重复元素
List list = new ArrayList();
list.add(“张三”);
list.add(“张三”);
list.add(“张三”);
System.out.println(list.size());//3
}
}
List的排序 Collections.sort()方法可以对List进行排序，前提是List中的元素实现了Comparable接口
package day19;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Day1905 {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("one");
list.add("two");
list.add("three");
list.add("four");
for (String str : list) {
System.out.print(str + " ");
}
System.out.println();
//String类的比较方式是按照ascii码表来比
Collections.sort(list);
for (String str : list) {
System.out.print(str + " ");
}
System.out.println();
}
}
package day19;
public class Student implements Comparable<Student> {
private int sno;
private String name;
private int score;
public Student(int sno, String name, int score) {
super();
this.sno = sno;
this.name = name;
this.score = score;
}
public int getSno() {
return sno;
}
public void setSno(int sno) {
this.sno = sno;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
} @
Override
public int compareTo(Student o) {
//分数高的排在前面，分数低的排在后面
return o.score - this.score;
}
}
使用比较器进行排序
package day19;
public class Person {
private String name;
private int age;
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
package day19;
import java.util.Comparator;
public class PersonCompartor implements Comparator<Person> {
@Override
public int compare(Person o1, Person o2) {
//按照年龄从小到大排
return o1.getAge() - o2.getAge();
}
}
package day19;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Day1908 {
public static void main(String[] args) {
List<Person> list = new ArrayList<Person>();
list.add(new Person("张三", 20));
list.add(new Person("李四", 18));
list.add(new Person("王五", 19));
//使用比较器进行排序，这样List中的元素就不必实现Comparable接口
Collections.sort(list, new PersonCompartor());
for (Person p : list) {
System.out.print(p.getName() + " ");
}
System.out.println();
}
将List转化为数组
package day19;
import java.util.ArrayList;
import java.util.List;
public class Day1909 {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("one");
list.add("two");
list.add("three");
list.add("four");
String[] arr = new String[list.size()];
// 将list转换为数组
list.toArray(arr);
for (String str : arr) {
System.out.println(str);
}
}
}
将数组转换为List
package day19;
import java.util.Arrays;
import java.util.List;
public class Day1910 {
public static void main(String[] args) {
String[] values = {"a", "b", "c", "d"};
//将数组转换为List
List<String> list = Arrays.asList(values);
for (String str : list) {
System.out.println(str);
}
}
}
LinkedList
LinkedList实现了List接口，LinkedList和ArrayList拥有同样的方法，但是内部的实现却不同。ArrayList内部使用数组来实现，LinkedList内部使用链表来实现。 数组是一块连续的内存单元，链表不是连续的内存单元。链表通过引用来
使链表中的元素关联起来。 LinkedList示意图：
import java.util.LinkedList;
import java.util.List;
public class Day1911 {
public static void main(String[] args) {
List<String> list = new LinkedList<String>();
list.add("one");
list.add("two");
list.add("three");
list.add("four");
for (String str : list) {
System.out.print(str + " ");
}
System.out.println();
}
}
LinkedList和ArrayList对比 ArrayList增删元素慢，因为需要拷贝整个数组。而LinkedList增删元素快，因为只需要修改引用。但是，这是理论上的，实际并非如此。但是ArrayList的查询速度明显快LinkedList。