集合类
集合按照其存储结构可以分为两大类，即单列集合Collection和双列集合Map。
Collection：单列集合类的根接口，用于存储一系列符合某种规则的元素，有List和Set两个重要子接口。
Map：双列集合类的根接口，用于存储具有键（Key）和值（Value）映射关系的元素。
Collection接口
Collection接口的方法
|
方法声明
|
方法声明
|
功能描述
|
|
添
加
|
boolean add(Object o)
|
向集合中添加一个元素
|
|
boolean addAll(Collection c)
|
将指定Collection中的所有元素添加到该集合
|
|
|
删
除
|
void clear()
|
删除该集合所有元素
|
|
boolean remove(Object o)
|
删除该集合指定元素
|
|
|
boolean removeAll(Collection c)
|
删除指定集合中所有元素
|
|
|
判
断
|
boolean isEmpty()
|
判断该集合是否为空
|
|
boolean contains(Object o)
|
判断该集合中是否包含某元素
|
|
|
boolean containsAll(Collection c)
|
判断该集合中是否包含指定集合中的所有元素
|
|
|
|
Iterator iterator()
|
返回在该集合的元素上进行迭代的迭代器，用于遍历该集合元素
|
|
|
int size()
|
获取该集合元素个数
|
List接口
List接口继承自Collection接口，在List集合中允许出现重复的元素，所有元素是通过一种线性方式进行存储的，可以通过索引访问指定元素。另外，List集合特点是元素有序，即元素的存入顺序和取出顺序一致。
List接口除了继承了Collection接口中的所有方法，还新增了一些特有方法：
List集合常用方法表
|
方法声明
|
功能描述
|
|
void add(int index,Object element)
|
将元素element插入在List集合的index处
|
|
boolean addAll(int index,Collection c)
|
将集合c包含的所有元素插入到List集合的index处
|
|
Object get(int index)
|
返回集合索引index处的元素
|
|
Object remove(int index)
|
删除index索引处的元素
|
|
Object set(int index,Object element)
|
将索引index处元素替换成element对象，并将替换后的元素返回
|
|
int indexOf(Object o)
|
返回对象o在List集合中出现的位置索引
|
|
int lastIndexOf(Object o)
|
返回对象o在List集合中最后一次出现的位置索引
|
|
List subList(int fromIndex,int toIndex)
|
返回从索引fromIndex（包括）到toIndex（不包括）处所有元素集合组成的子集合
|
ArrayList集合
ArrayList是List接口的一个实现类。ArrayList集合可以看作是一个长度可变的数组，在增加或删除元素时，会导致创建新数组，效率比较低，所以不适合做大量的增删操作。但这种数组的结构允许程序通过索引来访问元素，所以使用ArrayList查找元素很便捷。
import java.util.ArrayList;
public class Test{
public static void main(String[] args) {
ArrayList list = new ArrayList(); //创建ArrayList集合
list.add("stu1"); //添加元素
list.add("stu2");
list.add("stu3");
list.add("stu4");
System.out.println(list.toString());
System.out.println("集合长度："+list.size());
System.out.println("第二个元素："+list.get(1));
}
}
运行结果
[stu1, stu2, stu3, stu4]
集合长度：4
第二个元素：stu2
LinkedList集合
为了克服ArrayList增删效率低可以使用List接口的另一个实现类LinkedList。该集合内部维护了一个双向循环链表，链表中的每一个元素都使用引用的方式来记住它的前一个元素和后一个元素，从而将所有元素彼此连接起来。
LinkedList中定义的方法
|
方法声明
|
功能描述
|
|
void add(int index,E element)
|
在列表中的指定位置插入指定元素
|
|
void addFirst(Object o)
|
将指定元素插入到列表开头
|
|
void addLast(Object o)
|
将指定元素插入到列表结尾
|
|
Object getFirst()
|
返回此列表第一个元素
|
|
Object getLast()
|
返回此列表最后一个元素
|
|
Object removeFirst()
|
移除并返回此列表第一个元素
|
|
Object removeLast()
|
移除并返回此列表最后一个元素
|
import java.util.LinkedList;
public class Test{
public static void main(String[] args) {
LinkedList link = new LinkedList(); //创建LinkedList集合
link.add("stu1");
link.add("stu2");
link.add("stu3");
link.add("stu4");
System.out.println(link.toString());
link.add(3,"Student"); //指定位置插入元素
link.addFirst("First"); //第一个位置插入元素
System.out.println(link);
System.out.println(link.getFirst()); //取出第一个元素
link.remove(3); //移除指定位置元素
link.removeFirst(); //移除第一个元素
System.out.println(link);
System.out.println(link.removeLast()); //移除并返回最后一个元素
}
}
运行结果
[stu1, stu2, stu3, stu4]
[First, stu1, stu2, stu3, Student, stu4]
First
[stu1, stu2, Student, stu4]
stu4
Iterator接口
Iterator主要用于迭代访问（遍历）Collection中的元素，因此Iterator对象也被称为迭代器。
import java.util.ArrayList;
import java.util.Iterator;
public class Test{
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add("stu1");
list.add("stu2");
list.add("stu3");
list.add("stu4");
Iterator it = list.iterator(); //获取Iterator对象
while(it.hasNext()){ //判断ArrayList集合中是否存在下一个元素
Object obj = it.next(); //取出ArrayList中的元素
System.out.println(obj);
}
}
}
运行结果
stu1
stu2
stu3
stu4
当通过迭代器获取ArrayList集合中的元素时，都会将这些元素当作Object类型来看待，可以强制类型转换成特定类型的元素。
while(it.hasNext()){
Object obj = (String)it.next();
System.out.println(obj);
}
foreach循环
foreach循环用于遍历数组或集合中额元素，格式：
for(容器中元素类型 临时变量 : 容器变量){执行语句}
import java.util.ArrayList;
public class Test{
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add("stu1");
list.add("stu2");
list.add("stu3");
list.add("stu4");
for (Object obj:list) { //使用foreach循环遍历ArrayList对象
System.out.println(obj);
}
}
}
运行结果
stu1
stu2
stu3
stu4
注：①foreach循环遍历数组时，只能访问集合中的元素，不能对集合其进行修改。
public class Test{
public static void main(String[] args) {
String[] arr = {"aaa","bbb","ccc"};
System.out.println("foreach循环遍历数组:");
for (String str:arr) { //使用foreach循环遍历ArrayList对象
str = "ddd";
System.out.println(str);
}
System.out.println(arr[0]+arr[1]+arr[2]);
System.out.println("for循环遍历数组:");
for(int i=0;i<arr.length;i++){
arr[i] = "ddd";
System.out.println(arr[i]);
}
System.out.println(arr[0]+arr[1]+arr[2]);
}
}
运行结果
foreach循环遍历数组:
ddd
ddd
ddd
aaabbbccc
for循环遍历数组:
ddd
ddd
ddd
ddddddddd
②在使用Iterator迭代器对集合中的元素进行迭代时，如果调用了集合对象的remove()方法删除元素会出现异常。
import java.util.ArrayList;
import java.util.Iterator;
public class Test{
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add("Jack");
list.add("Annie");
list.add("Rose");
list.add("Tom");
Iterator it = list.iterator(); //获取Iterator对象
while(it.hasNext()){
Object obj = it.next();
if("Annie".equals(obj)){ //判断元素是否为Annie
list.remove(obj);
}
}
System.out.println(list);
}
}
运行结果
Exception in thread "main" java.util.ConcurrentModificationException
出现异常，原因是集合删除了元素会导致迭代器预期的迭代次数发生改变，导致迭代器结果不准确。
为了解决上述问题，可以利用break语句跳出迭代，
if("Annie".equals(obj)){
list.remove(obj);
break;
}
也可以利用迭代器本身的删除方法it.remove();
if("Annie".equals(obj)){
it.remove();
}
运行结果
[Jack, Rose, Tom]
ListIterator接口
Iterator迭代器是从集合的第一个元素像最后一个元素迭代，也就是正向迭代。为了使迭代方式跟家多元化，JDK中还定义了一个ListIterator迭代器，它是Iterator的子类，
ListIterator特有方法表
|
方法声明
|
功能描述
|
|
void add(Object o)
|
将指定元素插入列表（可选操作）
|
|
boolean hasPrevious()
|
如果以逆向遍历列表，列表迭代器有多个元素，则返回true
|
|
Object previous()
|
返回列表中的前一个元素
|
|
void remove()
|
从列表中移除由next或previous返回的最后一个元素（可选操作）
|
import java.util.ArrayList;
import java.util.ListIterator;
public class Test{
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add("stu1");
list.add("stu2");
list.add("stu3");
System.out.println(list);
//获得ListIterator对象，并传入一个int类型的参数指定迭代的起始位置
ListIterator it = list.listIterator(list.size());
while(it.hasPrevious()){ //判断该对象中是否有上一个元素
Object obj = it.previous(); //迭代该对象的上一个元素
System.out.println(obj+" ");
}
}
}
运行结果
[stu1, stu2, stu3]
stu3
stu2
stu1
注：ListIterator迭代器只能用于List集合。在这个过程中如果想增加元素不能调用集合的add()方法，需要使用ListIterator提供的add()方法，否则会出现并发修改异常。
while(it.hasPrevious()){ //判断该对象中是否有上一个元素
Object obj = it.previous(); //迭代该对象的上一个元素
if("stu3".equals(obj)){
it.add("stu");
}
}
运行结果
[stu1, stu2, stu, stu3]
Enumeration接口
在JDK1.2以前遍历集合使用Enumeration接口，它的方法和Iterator类似。JDK中提供了一个Vector集合，是List接口的一个实现类，用法与ArrayList完全相同，区别在于Vector集合是线程安全的，而ArrayList集合是线程不安全的。
import java.util.Enumeration;
import java.util.Vector;
public class Test{
public static void main(String[] args) {
Vector v = new Vector();
v.add("stu1");
v.add("stu2");
v.add("stu3");
Enumeration en = v.elements(); //elements()方法获取Enumeration对象
while(en.hasMoreElements()){ //判断该对象是否有更多元素
Object obj= en.nextElement(); //取出该对象的下一个元素
System.out.println(obj);
}
}
}
运行结果
stu1
stu2
stu3
Set接口
Set接口和List接口同样继承自Collection接口，它与Collection接口中的方法基本一致，并没有进行功能上的扩充，只是比Collection更加严格。
Set接口中元素无序，并且都会以某种规则保证存入的元素不会出现重复。
Set接口有两个实现类：HashSet和TreeSet。
HashSet集合
HashSet是Set接口的一个实现类，它所存储的元素是不可重复并且无序的。
下图为HashSet的存储过程：
import java.util.HashSet;
import java.util.Iterator;
public class Test{
public static void main(String[] args) {
HashSet set = new HashSet();
set.add("Jack");
set.add("Eve");
set.add("Rose");
set.add("Rose");
Iterator it = set.iterator();
while(it.hasNext()){
Object obj = it.next();
System.out.println(obj);
}
}
}
运行结果
Eve
Rose
Jack
结果可以看出无重复且无序。
字符串存入HashSet时，String类已经重写了hashCode()和equals()方法。
如果将Student对象存入HashSet：
import java.util.HashSet;
class Student{
String id;
String name;
public Student(String id,String name){
this.id = id;
this.name = name;
}
public String toString(){
return id+":"+name;
}
}
public class Test{
public static void main(String[] args) {
HashSet set = new HashSet();
Student stu1 = new Student("1","Jack");
Student stu2 = new Student("2","Rose");
Student stu3 = new Student("2","Rose");
set.add(stu1);
set.add(stu2);
set.add(stu3);
System.out.println(set);
}
}
运行结果
[2:Rose, 1:Jack, 2:Rose]
运行结果出现了两个“2:Rose”，这是因为在定义Student类时没有重写hashCode()和equals()方法。
import java.util.HashSet;
class Student{
private String id;
private String name;
public Student(String id,String name){
this.id = id;
this.name = name;
}
//重写toString()方法
public String toString(){
return id+":"+name;
}
//重写hashCode()方法
public int hashCode(){
return id.hashCode();
}
//重写equals()方法
public boolean equals(Object obj){
if(this == obj){ //判断是否为同一个对象
return true; //如果是，直接返回true
}
if(!(obj instanceof Student)){ //判断obj是否为Student类型
return false; //如果不是，返回false
}
Student stu = (Student) obj; //将对象强转为Student类型
boolean b =this.id.equals(stu.id); //判断id值是否相等
return b; //返回判断结果
}
}
public class Test{
public static void main(String[] args) {
HashSet set = new HashSet();
Student stu1 = new Student("1","Jack");
Student stu2 = new Student("2","Rose");
Student stu3 = new Student("2","Rose");
set.add(stu1);
set.add(stu2);
set.add(stu3);
System.out.println(set);
}
}
运行结果
[1:Jack, 2:Rose]
总的来说，如果HashSet集合传入的对象没有重写hashCode()和equals()方法，就会出现重复元素，方法一可以在该对象中重写这俩方法，方法二可以将对象用toString()方法以字符串形式加入集合，这两种都可以去掉集合中重复元素。
TreeSet集合
TreeSet是Set接口的另一个实现类，它内部采用自平衡的排序二叉树来存储元素，这样的结构可以保证TreeSet集合中没有重复元素且可以对元素进行排序。
import java.util.Iterator;
import java.util.TreeSet;
public class Test{
public static void main(String[] args) {
TreeSet ts = new TreeSet(); //创建TreeSet集合
ts.add("Jack");
ts.add("Helena");
ts.add("Helena");
ts.add("Eve");
Iterator it = ts.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
运行结果
Eve
Helena
Jack
可以看出结果按照字母表的顺序打印出来。
集合中的元素在进行比较时，都会调用Comparable接口中定义的compare To()方法，因此要想对集合中的元素进行排序，就必须实现Comparable接口。JDK中大部分类都实现了该接口，如Integer、Double和String等。
import java.util.Iterator;
import java.util.TreeSet;
class Student implements Comparable{
String name;
int age;
public Student(String name,int age){
this.name = name;
this.age = age;
}
//重写toString()方法，返回描述信息
public String toString(){
return name+":"+age;
}
//重写Comparable接口的compareTo()方法
public int compareTo(Object obj){
Student s = (Student)obj; //将比较对象强转为Student类型
if(this.age>s.age){
return 1;
}
if(this.age==s.age){
return this.name.compareTo(s.name); //将比较方法返回
}
return -1;
}
}
public class Test{
public static void main(String[] args) {
TreeSet ts = new TreeSet();
ts.add(new Student("Jack",19));
ts.add(new Student("Rose",18));
ts.add(new Student("Tome",19));
ts.add(new Student("Rose",18));
Iterator it = ts.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
}
}
运行结果
Rose:18
Jack:19
Tome:19
可以看出先比较年龄，根据比较结果返回1和-1，当age相同时在比较name。
如果，不想按照定义的compareTo()方法进行排序，例如想按照字符串长度排序，这时就可以通过自定义比较器的方式对TreeSet()集合中的元素排序，即实现Comparator接口，再在创建TreeSet集合时指定比较器。
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
class MyComparator implements Comparator {
public int compare(Object obj1,Object obj2){
String s1 = (String)obj1;
String s2 = (String)obj2;
int temp = s1.length()-s2.length();
return temp;
}
}
public class Test{
public static void main(String[] args) {
//创建TreeSet对象时传入自定义比较器
TreeSet ts = new TreeSet(new MyComparator());
ts.add("Jack");
ts.add("Helena");
ts.add("Eve");
Iterator it = ts.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
}
}
运行结果
Eve
Jack
Helena
Map接口
Map接口是一种双列集合，它的每个元素都包含一个键对象Key和一个值对象Value，键和值对象之间存在一种对应关系，称为映射。
Map集合常用方法表
|
|
方法声明
|
功能描述
|
|
存
入
|
void put(Object key,Object value)
|
将指定的值与此映射中的指定键关联（可选操作）
|
|
取
出
|
Object get(Object key)
|
返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回null
|
|
判
断
|
boolean containsKey(Object key)
|
如果此映射包含指定键的映射关系，则返回true
|
|
boolean containsValue(Object value)
|
如果此映射将一个或多个键映射到指定值，则返回true
|
|
|
获取键
|
Set keySet()
|
返回此映射中包含的键的Set视图
|
|
获取值
|
Collection<V> values()
|
返回此映射中包含的值的Collection视图
|
|
|
Set<Map.Entry<K,V>>entrySet()
|
返回此映射中包含的映射关系的Set视图
|
Map接口最常用的两个实现类：HashMap和TreeMap。
HashMap集合
HashMap集合是Map接口的一个实现类，用于存储键值映射关系，但必须保证不出现重复的键。
import java.util.HashMap;
import java.util.Map;
public class Test{
public static void main(String[] args) {
Map map = new HashMap(); //创建Map对象
map.put("1","Jack"); //存储键和值
map.put("2","Rose");
map.put("3","Lucy");
map.put("3","Mary");
map.put("4","Jack");
System.out.println("1: "+map.get("1")); //根据键获取值
System.out.println("2: "+map.get("2"));
System.out.println("3: "+map.get("3"));
System.out.println("4: "+map.get("4"));
}
}
运行结果
1: Jack
2: Rose
3: Mary
4: Jack
从结果可以看出，出现相同的键会被覆盖，简而言之：键相同，值覆盖。
遍历Map中所有的键值有两种方式可以实现：
①先遍历键，在获取对应的值：
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Test{
public static void main(String[] args) {
Map map = new HashMap(); //创建Map对象
map.put("1","Jack"); //存储键和值
map.put("2","Rose");
map.put("3","Lucy");
Set keySet = map.keySet(); //获取键的集合
System.out.println(keySet);
Iterator it = keySet.iterator(); //迭代键的集合
while (it.hasNext()){
Object key = it.next();
Object value = map.get(key); //获取每个键对应的值
System.out.println(key+":"+value);
}
}
}
运行结果
[1, 2, 3]
1:Jack
2:Rose
3:Lucy
②先遍历获取集合中的所有映射关系，然后从映射关系中取出键和值：
首先调用Map对象的entrySet()方法获得存储在Map中所有映射的Set集合，这个集合中存放了Map.Entry类型的元素（Entry是Map接口的内部类），每个Map.Entry对象代表Map中的一个键值对，然后迭代Set集合。
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Test{
public static void main(String[] args) {
Map map = new HashMap(); //创建Map对象
map.put("1","Jack"); //存储键和值
map.put("2","Rose");
map.put("3","Lucy");
Set entrySet = map.entrySet(); //获取存储再Map中的所有映射的Set集合
System.out.println(entrySet);
Iterator it = entrySet.iterator();
while (it.hasNext()){
Map.Entry entry = (Map.Entry) (it.next());//获取集合中键值对映射关系
Object key = entry.getKey(); //获取Entry中的键
Object value = entry.getValue(); //获取Entry中的值
System.out.println(key+":"+value);
}
}
}
运行结果
[1=Jack, 2=Rose, 3=Lucy]
1:Jack
2:Rose
3:Lucy
在Map中，提供了values()方法直接获取Map中存储所有值的Collection集合。
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class Test{
public static void main(String[] args) {
Map map = new HashMap(); //创建Map对象
map.put("1","Jack"); //存储键和值
map.put("2","Rose");
map.put("3","Lucy");
Collection values = map.values();
System.out.println(values);
Iterator it = values.iterator();
while (it.hasNext()){
Object value = it.next();
System.out.println(value);
}
}
}
运行结果
[Jack, Rose, Lucy]
Jack
Rose
Lucy
HashMap迭代出来的元素顺序和存入的顺序有可能不一样。LinkedHashMap类是HashMap类的子类，能使Map元素迭代的顺序与存入的顺序一致。
import java.util.*;
public class Test{
public static void main(String[] args) {
Map map = new LinkedHashMap(); //创建Map对象
map.put("1","Jack"); //存储键和值
map.put("2","Rose");
map.put("3","Lucy");
Set keySet = map.keySet(); //获取键的集合
System.out.println(keySet);
Iterator it = keySet.iterator(); //迭代键的集合
while (it.hasNext()){
Object key = it.next();
Object value = map.get(key); //获取每个键对应的值
System.out.println(key+":"+value);
}
}
}
运行结果
[1, 2, 3]
1:Jack
2:Rose
3:Lucy
TreeMap集合
TreeMap集合是Map接口的一个实现类，是用来存储键值映射关系的，其中不允许出现重复的键。
import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;
public class Test{
public static void main(String[] args) {
TreeMap tm = new TreeMap(); //创建TreeMap对象
tm.put("1","Jack"); //存储键和值
tm.put("2","Rose");
tm.put("3","Lucy");
System.out.println(tm);
Set keySet = tm.keySet(); //获取键的集合
System.out.println(keySet);
Iterator it = keySet.iterator(); //迭代键的集合
while (it.hasNext()){
Object key = it.next();
Object value = tm.get(key); //获取每个键对应的值
System.out.println(key+":"+value);
}
}
}
运行结果
{1=Jack, 2=Rose, 3=Lucy}
[1, 2, 3]
1:Jack
2:Rose
3:Lucy
可以看出，取出的元素按照学号的自然顺序进行了排序，这是因为学号为String类型，String类型实现了Comparable接口。
也可以通过自定义比较器的方式对键进行排序：
import java.util.*;
//自定义比较器
class MyComparator implements Comparator{
//是西安比较方法
public int compare(Object obj1,Object obj2){
String id1 = (String) obj1; //将Object类型的参数强转为String类型
String id2 = (String) obj2;
return id2.compareTo(id1); //将比较之后的值返回
}
}
public class Test{
public static void main(String[] args) {
TreeMap tm = new TreeMap(new MyComparator()); //传入一个自定义比较器
tm.put("1","Jack"); //存储键和值
tm.put("2","Rose");
tm.put("3","Lucy");
Set keySet = tm.keySet(); //获取键的集合
System.out.println(keySet);
Iterator it = keySet.iterator(); //迭代键的集合
while (it.hasNext()){
Object key = it.next();
Object value = tm.get(key); //获取每个键对应的值
System.out.println(key+":"+value);
}
}
}
运行结果
[3, 2, 1]
3:Lucy
2:Rose
1:Jack
由于方法中返回的是“id2.compareTo(id1)”，因此最终输出结果会按照与字典顺序相反的顺序进行排序。
Properties集合
Map接口中还有一个实现类Hashtable，它和HashMap十分相似，区别在于Hashtable是线程安全的。Hashtable存取元素速度很慢，目前基本被HashMap类所取代，但Hashtable类有一个子类Properties在实际应用中非常重要，主要用来存储字符串类型的键和值。
在实际开发中，经常使用Properties集合来存取应用的配置项。
import java.util.Enumeration;
import java.util.Properties;
public class Test{
public static void main(String[] args) {
Properties p = new Properties(); //创建Properties对象
p.setProperty("backgrounp-color","red"); //存入
p.setProperty("Font-size","14px");
p.setProperty("Language","chinese");
System.out.println(p);
Enumeration names = p.propertyNames(); //获取Enumeration对象多有键的枚举
while (names.hasMoreElements()){ //循环遍历所有键
String key = (String) names.nextElement();
String value = p.getProperty(key); //获取对应键的值
System.out.println(key+"="+value);
}
}
}
运行结果
{Language=chinese, Font-size=14px, backgrounp-color=red}
Language=chinese
backgrounp-color=red
Font-size=14px
Properties类中，针对字符串的存取提供了两个专用的方法setProperty()和getProperty()。
泛型
import java.util.ArrayList;
public class Test{
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add("String");
list.add("Integer");
list.add(1);
for (Object obj :list
) {
String str = (String)obj;
}
}
}
运行结果
Exception in thread "main" java.lang.ClassCastException: class java.lang.Integer cannot be cast to class java.lang.String (java.lang.Integer and java.lang.String are in module java.base of loader 'bootstrap')
at Test.main(Test.java:11)
是因为Integer对象无法转换String类型。
为了解决该问题，Java中引入了“参数化类型”这个概念，即泛型。在定义集合类时，使用“<参数化类型>”的方式指定该类中方法操作的数据类型，具体格式：
ArrayList<参数化类型>list=new ArrayList<参数化类型>();
上面改写为ArrayList<String> list = new ArrayList<String>();就会显示编译不通过，从而解决问题。
也可以自定义泛型，需要定义两个方法，一个用于保存数据save()，一个用于取出数据get()，格式为：
void save(参数类型 参数){......}
返回值 参数类型get(){......}
下面在实例化对象时将参数T指定为Integer类型
class cachePool<T>{ //在创建类时，声明参数类型为T
T temp;
public void save(T temp){ //在创建save()方法时，指定参数类型为T
this.temp = temp;
}
public T get(){ //在创建get()方法时，指定返回类型为T
return temp;
}
}
public class Test{
public static void main(String[] args) {
//在实例化对象时，传入参数为Integer类型
cachePool<Integer>pool = new cachePool<Integer>();
pool.save(new Integer(1));
Integer temp = pool.get();
System.out.println(temp);
}
}
运行结果
1
Collections工具类
Collections类中提供了大量的方法用于对集合中的元素进行排序、查找和修改等操作。
Collections常用方法表
|
方法声明
|
功能描述
|
|
static <T> boolean addAll(Collection<?Super T>c,T... elements)
|
将指定元素添加到指定的collection中
|
|
static void reverse(List list)
|
反转指定List集合中元素顺序
|
|
static void sort(List list)
|
对List集合中元素进行随机排序（模拟玩扑克中的洗牌）
|
|
static void sort(List list)
|
根据元素自然顺序对List集合中的元素进行排序
|
|
static void swap(List list,int i,int j)
|
将指定List集合中i处元素和j处元素进行交换
|
import java.util.ArrayList;
import java.util.Collections;
public class Test{
public static void main(String[] args) {
ArrayList list = new ArrayList();
Collections.addAll(list,"C","Z","B","K"); //添加元素
System.out.println("排序前："+list);
Collections.reverse(list); //反转集合
System.out.println("反转后："+list);
Collections.sort(list); //按自然顺序进行排序
System.out.println("按自然顺序排序后："+list);
Collections.shuffle(list); //随机排序
System.out.println("洗牌后："+list);
Collections.swap(list,0,3); //i和j处元素交换
System.out.println("0和3位置交换后："+list);
Collections.swap(list,list.indexOf("Z"),list.indexOf("K")); //Z和K元素交换
System.out.println("Z和K位置交换后："+list);
}
}
运行结果
排序前：[C, Z, B, K]
反转后：[K, B, Z, C]
按自然顺序排序后：[B, C, K, Z]
洗牌后：[Z, C, B, K]
0和3位置交换后：[K, C, B, Z]
Z和K位置交换后：[Z, C, B, K]
Collections类还提供了一些常用方法用于查找、替换集合中的元素。
Collections常用方法表
|
方法声明
|
功能描述
|
|
static int binarySearch(List list,Object key)
|
使用二分法搜索指定对象在List集合中的索引，查找List集合中的元素必须是有序的
|
|
static Object max(Collection col)
|
根据元素的自然顺序，返回给定集合中最大元素
|
|
static Object min(Collection col)
|
根据元素的自然顺序，返回给定集合中最小元素
|
|
static boolean replaceAll(List list,Object oldVal,Object newVal)
|
用一个新的newVal替换List集合中所有的旧值oldVal
|
import java.util.ArrayList;
import java.util.Collections;
public class Test{
public static void main(String[] args) {
ArrayLiyunt list = new ArrayList();
Collections.addAll(list,-3,2,9,5,8);
System.out.println("集合中的元素："+list);
System.out.println("集合中最大元素："+Collections.max(list));
System.out.println("集合中最小元素："+Collections.min(list));
Collections.replaceAll(list,8,0); //把集合中的8用0替换掉
System.out.println("替换后的集合："+list);
}
}
运行结果
集合中的元素：[-3, 2, 9, 5, 8]
集合中最大元素：9
集合中最小元素：-3
替换后的集合：[-3, 2, 9, 5, 0]
Arrays工具类
①sort()方法排序
import java.util.Arrays;
public class Test{
public static void main(String[] args) {
int[] arr = {9,8,3,5,2};
System.out.print("排序前：");
for (int i=0;i<5;i++){
System.out.print(arr[i]+" ");
}
System.out.print("排序后：");
Arrays.sort(arr);
for (int i=0;i<5;i++){
System.out.print(arr[i]+" ");
}
}
}
运行结果
排序前：9 8 3 5 2 排序后：2 3 5 8 9
②binarySearch(Object[] a,Object key)方法查找元素（只针对排序后的数组，采用二分法查找）
import java.util.Arrays;
public class Test{
public static void main(String[] args) {
int[] arr = {9,8,3,5,2};
Arrays.sort(arr);
int index = Arrays.binarySearch(arr,3); //查找指定元素3
System.out.println("数组排序后[2,3,5,8,9]元素3的索引是："+index);
}
}
运行结果
数组排序后[2,3,5,8,9]元素3的索引是：1
③copyOfRange(int[] original,int from,int to)方法拷贝元素
该方法中original表示被复制的数组，from表示被复制元素的初始索引（包括），to表示被复制元素的最后索引（不包括）。
import java.util.Arrays;
public class Test{
public static void main(String[] args) {
int[] arr = {9,8,3,5,2};
int[] copied = Arrays.copyOfRange(arr,1,7);
for(int i=0;i<copied.length;i++){
System.out.print(copied[i]+" ");
}
}
}
运行结果
8 3 5 2 0 0
④fill(Object[] a,Object val)方法填充元素
import java.util.Arrays;
public class Test{
public static void main(String[] args) {
int[] arr = {9,8,3,5,2};
Arrays.fill(arr,8); //用8替换数组中的每一个值
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
}
}
运行结果
8 8 8 8 8
⑤toString(int[] arr)方法把数组转换为字符串
import java.util.Arrays;
public class Test{
public static void main(String[] args) {
int[] arr = {9,8,3,5,2};
String arrString = Arrays.toString(arr);
System.out.println(arrString);
}
}
运行结果
[9, 8, 3, 5, 2]
注：该方法并不是对Object类toString()方法的重写，只是用于返回指定数组的字符串形式。