Java API ＶI
集合框架
1.什么是集合
集合与数组一样,可以保存一组元素,并且提供了操作元素的相关方法,使用更方便。
java集合框架中相关接口
java.util.Collection接口:
java.util.Collection是所有集合的顶级接口.Collection下面有多种实现类,因此我们有更多的数据结构可供选择.
Collection下面有两个常见的子接口:
- java.util.List:线性表.是可重复集合,并且有序.
- java.util.Set:不可重复的集合,大部分实现类是无序的.
这里可重复指的是集合中的元素是否可以重复,而判定重复元素的标准是依靠元素自身equals比较
的结果.为true就认为是重复元素.
package collection;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo {
public static void main(String[] args) {
Collection c = new ArrayList();
/*
boolean add(E e)
向当前集合中添加一个元素.当元素成功添加后返回true
*/
c.add("one");
c.add("two");
c.add("three");
c.add("four");
c.add("five");
System.out.println(c);
/*
int size()
返回当前集合的元素个数
*/
int size = c.size();
System.out.println("size:"+size);
/*
boolean isEmpty()
判断当前集合是否为空集(不含有任何元素)
*/
boolean isEmpty = c.isEmpty();
System.out.println("是否为空集:"+isEmpty);
/*
清空集合
*/
c.clear();
System.out.println(c);
System.out.println("size:"+c.size());//0
System.out.println("是否为空集:"+c.isEmpty());
}
}
2.集合与元素equals方法相关的方法
package collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
/**
* 集合的很多操作有与元素的equals方法相关。
*/
public class CollectionDemo2 {
public static void main(String[] args) {
// Collection c = new ArrayList();
Collection c = new HashSet();
c.add(new Point(1,2));
c.add(new Point(3,4));
c.add(new Point(5,6));
c.add(new Point(7,8));
c.add(new Point(1,2));
/*
集合重写了Object的toString方法，输出的格式为:
[元素1.toString(), 元素2.toString(), ....]
*/
System.out.println(c);
Point p = new Point(1,2);
/*
boolean contains(Object o)
判断当前集合是否包含给定元素，这里判断的依据是给定元素是否与集合
现有元素存在equals比较为true的情况。
*/
boolean contains = c.contains(p);
System.out.println("包含:"+contains);
/*
remove用来从集合中删除给定元素，删除的也是与集合中equals比较
为true的元素。注意，对于可以存放重复元素的集合而言，只删除一次。
*/
c.remove(p);
System.out.println(c);
}
}
3.集合存放的是元素的引用
集合只能存放引用类型元素,并且存放的是元素的引用
package collection;
import java.util.ArrayList;
import java.util.Collection;
/**
* 集合只能存放引用类型元素，并且存放的是元素的引用(地址)
*/
public class CollectionDemo3 {
public static void main(String[] args) {
Collection c = new ArrayList();
Point p = new Point(1,2);
c.add(p);
System.out.println("p:"+p);//p:(1,2)
System.out.println("c:"+c);//c:[(1,2)]
p.setX(2);
System.out.println("p:"+p);//p:(2,2)
System.out.println("c:"+c);//c:[(2,2)]
}
}
为方便大家学习理解，将军给大家准备了图解，。！
代码图解如下：
4.集合间的操作
集合提供了如取并集,删交集,判断包含子集等操作
package collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
/**
* 集合间的操作
*/
public class CollectionDemo4 {
public static void main(String[] args) {
// Collection c1 = new ArrayList();
Collection c1 = new HashSet();//不可重复元素
c1.add("java");
c1.add("c");
c1.add("c++");
System.out.println("c1:"+c1);
Collection c2 = new ArrayList();
c2.add("android");
c2.add("ios");
c2.add("java");
System.out.println("c2:"+c2);
/*
boolean addAll(Collection c)
将给定集合中的所有元素添加到当前集合中。当前集合若发生了改变则返回true
*/
boolean tf = c1.addAll(c2);
System.out.println(tf);
System.out.println("c1:"+c1);
System.out.println("c2:"+c2);
Collection c3 = new ArrayList();
c3.add("ios");
c3.add("c++");
c3.add("php");
System.out.println("c3:"+c3);
/*
boolean containsAll(Collection c)
判断当前集合是否包含给定集合中的所有元素
*/
boolean contains = c1.containsAll(c3);
System.out.println("包含所有元素:"+contains);
/*
boolean removeAll(Collection c)
删除当前集合中与给定集合中的共有元素
*/
c1.removeAll(c3);
System.out.println("c1:"+c1);
System.out.println("c3:"+c3);
}
}
5. 集合的遍历
Collection提供了统一的遍历集合方式:迭代器模式
Iterator iterator()
该方法会获取一个用于遍历当前集合元素的迭代器.
java.util.Iterator接口
迭代器接口,定义了迭代器遍历集合的相关操作.
不同的集合都实现了一个用于遍历自身元素的迭代器实现类,我们无需记住它们的名字,用多态的角度把他们看做为Iterator即可.
迭代器遍历集合遵循的步骤为:问,取,删.其中删除元素不是必要操作
package collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
* Collection接口没有定义单独获取某一个元素的操作，因为不通用。
* 但是Collection提供了遍历集合元素的操作。该操作是一个通用操作，无论什么类型的
* 集合都支持此种遍历方式:迭代器模式。
*
* Iterator iterator() die(二声)
* 该方法会获取一个用于遍历当前集合元素的迭代器
*
* java.util.Iterator接口，是迭代器接口，规定了迭代器遍历集合的相关操作，不同的
* 集合都提供了一个用于遍历自身元素的迭代器实现类，不过我们不需要直到它们的名字，以
* 多态的方式当成Iterator使用即可。
* 迭代器遍历集合遵循的步骤为:问->取->删
* 其中删除不是必须操作。
*
*/
public class IteratorDemo {
public static void main(String[] args) {
Collection c = new ArrayList();
c.add("one");
c.add("two");
c.add("three");
c.add("four");
c.add("five");
System.out.println(c);
//获取迭代器
Iterator it = c.iterator();
/*
迭代器提供的相关方法：
boolean hasNext()
判断集合是否还有元素可以遍历
E next()
获取集合下一个元素(第一次调用时就是获取第一个元素，以此类推)
*/
while(it.hasNext()){
String str = (String)it.next();
System.out.println(str);
}
System.out.println(c);
}
}
迭代器遍历过程中不得通过集合的方法增删元素
package collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
* Collection接口没有定义单独获取某一个元素的操作，因为不通用。
* 但是Collection提供了遍历集合元素的操作。该操作是一个通用操作，无论什么类型的
* 集合都支持此种遍历方式:迭代器模式。
*
* Iterator iterator() die(二声)
* 该方法会获取一个用于遍历当前集合元素的迭代器
*
* java.util.Iterator接口，是迭代器接口，规定了迭代器遍历集合的相关操作，不同的
* 集合都提供了一个用于遍历自身元素的迭代器实现类，不过我们不需要直到它们的名字，以
* 多态的方式当成Iterator使用即可。
* 迭代器遍历集合遵循的步骤为:问->取->删
* 其中删除不是必须操作。
*
*/
public class IteratorDemo {
public static void main(String[] args) {
Collection c = new ArrayList();
c.add("one");
c.add("#");
c.add("two");
c.add("#");
c.add("three");
c.add("#");
c.add("four");
c.add("#");
c.add("five");
System.out.println(c);
//获取迭代器
Iterator it = c.iterator();
/*
迭代器提供的相关方法：
boolean hasNext()
判断集合是否还有元素可以遍历
E next()
获取集合下一个元素(第一次调用时就是获取第一个元素，以此类推)
*/
while(it.hasNext()){
String str = (String)it.next();
System.out.println(str);
if("#".equals(str)){
/*
迭代器要求遍历的过程中不得通过集合的方法增删元素
否则会抛出异常:ConcurrentModificationException
*/
// c.remove(str);
/*
迭代器的remove方法可以将通过next方法获取的元素从集合
中删除。
*/
it.remove();
}
}
System.out.println(c);
}
}
增强型for循环
JDK5之后推出了一个特性:增强型for循环
- 也称为新循环,使得我们可以使用相同的语法遍历集合或数组.
- 语法:
for(元素类型 变量名 : 集合或数组){
循环体
}
package collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
* JDK5推出时，推出了一个新的特性:增强型for循环
* 也称为新循环，它可以用相同的语法遍历集合或数组。
*
* 新循环是java编译器认可的，并非虚拟机。
*/
public class NewForDemo {
public static void main(String[] args) {
String[] array = {"one","two","three","four","five"};
for(int i=0;i<array.length;i++){
String str = array[i];
System.out.println(str);
}
for(String str : array){
System.out.println(str);
}
Collection c = new ArrayList();
c.add("one");
c.add("two");
c.add("three");
c.add("four");
c.add("five");
//迭代器遍历
Iterator it = c.iterator();
while(it.hasNext()){
String str = (String)it.next();
System.out.println(str);
}
//新循环遍历
for(Object o : c){
String str = (String)o;
System.out.println(str);
}
}
}
6.泛型
JDK5之后推出的另一个特性:泛型
泛型也称为参数化类型,允许我们在使用一个类时指定它当中属性,方法参数或返回值的类型.
- 泛型在集合中被广泛使用,用来指定集合中的元素类型.
- 有泛型支持的类在使用时若不指定泛型的具体类型则默认为原型Object
package collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
* JDK5推出时，推出了一个新的特性:增强型for循环
* 也称为新循环，它可以用相同的语法遍历集合或数组。
*
* 新循环是java编译器认可的，并非虚拟机。
*/
public class NewForDemo {
public static void main(String[] args) {
String[] array = {"one","two","three","four","five"};
for(int i=0;i<array.length;i++){
String str = array[i];
System.out.println(str);
}
for(String str : array){
System.out.println(str);
}
/*
* 泛型 JDK5之后推出的另一个特性。
* 泛型也称为参数化类型，允许我们在使用一个类时指定它里面属性的类型，
* 方法参数或返回值的类型，使得我们使用一个类时可以更灵活。
* 泛型被广泛应用于集合中，用来指定集合中的元素类型。
* 支持泛型的类在使用时如果未指定泛型，那么默认就是原型Object
*
* Collection接口的定义
* public interface Collection<E> ... {
*
* Collection<E> 这里的<E>就是泛型
*
* Collection中add方法的定义，参数为E
* boolean add(E e)
*/
Collection<String> c = new ArrayList<>();
c.add("one");//编译器会检查add方法的实参是否为String类型
c.add("two");
c.add("three");
c.add("four");
c.add("five");
// c.add(123);//编译不通过
//迭代器遍历
//迭代器也支持泛型，指定的与其遍历的集合指定的泛型一致即可
Iterator<String> it = c.iterator();
while(it.hasNext()){
//编译器编译代码时会根据迭代器指定的泛型补充造型代码
String str = it.next();//获取元素时无需在造型
System.out.println(str);
}
//新循环遍历
for(String str : c){
System.out.println(str);
}
}
}
7. List集
java.util.List接口,继承自Collection.
List集合是可重复集,并且有序,提供了一套可以通过下标操作元素的方法
常用实现类:
- java.util.ArrayList:内部使用数组实现,查询性能更好.
- java.util.LinkedList:内部使用链表实现,首尾增删元素性能更好.
List集合常见方法
get()与set()
package collection;
import java.util.ArrayList;
import java.util.List;
/**
* List集合
* List是Collection下面常见的一类集合。
* java.util.List接口是所有List的接口，它继承自Collection。
* 常见的实现类:
* java.util.ArrayList:内部由数组实现，查询性能更好。
* java.util.LinkedList:内部由链表实现，增删性能更好。
*
* List集合的特点是:可以存放重复元素，并且有序。其提供了一套可以通过下标
* 操作元素的方法。
*/
public class ListDemo {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
// List<String> list = new LinkedList<>();
list.add("one");
list.add("two");
list.add("three");
list.add("four");
list.add("five");
/*
E get(int index)
获取指定下标对应的元素
*/
//获取第三个元素
String e = list.get(2);
System.out.println(e);
for(int i=0;i<list.size();i++){
e = list.get(i);
System.out.println(e);
}
/*
E set(int index,E e)
将给定元素设置到指定位置，返回值为该位置原有的元素。
替换元素操作
*/
//[one,six,three,four,five]
String old = list.set(1,"six");
System.out.println(list);
System.out.println("被替换的元素是:"+old);
}
}
重载的add()和remove()
package collection;
import java.util.ArrayList;
import java.util.List;
/**
* List集合提供了一对重载的add,remove方法
*/
public class ListDemo2 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("one");
list.add("two");
list.add("three");
list.add("four");
list.add("five");
System.out.println(list);
/*
void add(int index,E e)
将给定元素插入到指定位置
*/
//[one,two,six,three,four,five]
list.add(2,"six");
System.out.println(list);
/*
E remove(int index)
删除并返回指定位置上的元素
*/
//[one,six,three,four,five]
String e = list.remove(1);
System.out.println(list);
System.out.println("被删除的元素:"+e);
}
}
subList()方法
package collection;
import java.util.ArrayList;
import java.util.List;
/**
* List subList(int start,int end)
* 获取当前集合中指定范围内的子集。两个参数为开始与结束的下标(含头不含尾)
*/
public class ListDemo3 {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
for(int i=0;i<10;i++){
list.add(i);
}
System.out.println(list);
//获取3-7这部分
List<Integer> subList = list.subList(3,8);
System.out.println(subList);
//将子集每个元素扩大10倍
for(int i=0;i<subList.size();i++){
subList.set(i,subList.get(i) * 10);
}
//[30,40,50,60,70]
System.out.println(subList);
/*
对子集元素的操作就是对原集合对应元素的操作
*/
System.out.println(list);
//删除list集合中的2-8
list.subList(2,9).clear();
System.out.println(list);
}
}
8.集合与数组的转换
集合转换为数组
Collection提供了一个方法:toArray,可以将当前集合转换为一个数组
package collection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* 集合转换为数组
* Collection提供了方法toArray可以将当前集合转换为一个数组
*/
public class CollectionToArrayDemo {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("one");
list.add("two");
list.add("three");
list.add("four");
list.add("five");
System.out.println(list);
// Object[] array = list.toArray();
/*
重载的toArray方法要求传入一个数组，内部会将集合所有元素存入该数组
后将其返回（前提是该数组长度>=集合的size）。如果给定的数组长度不足，
则方法内部会自行根据给定数组类型创建一个与集合size一致长度的数组并
将集合元素存入后返回。
*/
String[] array = list.toArray(new String[list.size()]);
System.out.println(array.length);
System.out.println(Arrays.toString(array));
}
}
数组转换为List集合
数组的工具类Arrays提供了一个静态方法asList(),可以将一个数组转换为一个List集合
package collection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* 数组转换为List集合
* 数组的工具类Arrays提供了一个静态方法asList，可以将数组转换为一个List集合。
*/
public class ArrayToListDemo {
public static void main(String[] args) {
String[] array = {"one","two","three","four","five"};
System.out.println(Arrays.toString(array));
List<String> list = Arrays.asList(array);
System.out.println(list);
list.set(1,"six");
System.out.println(list);
//数组跟着改变了。注意:对数组转换的集合进行元素操作就是对原数组对应的操作
System.out.println(Arrays.toString(array));
/*
由于数组是定长的，因此对该集合进行增删元素的操作是不支持的，会抛出
异常:java.lang.UnsupportedOperationException
*/
// list.add("seven");
/*
若希望对集合进行增删操作，则需要自行创建一个集合，然后将该集合元素
导入。
*/
// List<String> list2 = new ArrayList<>();
// list2.addAll(list);
/*
所有的集合都支持一个参数为Collection的构造方法，作用是在创建当前
集合的同时包含给定集合中的所有元素
*/
List<String> list2 = new ArrayList<>(list);
System.out.println("list2:"+list2);
list2.add("seven");
System.out.println("list2:"+list2);
}
}
9.集合的排序
java.util.Collections类
Collections是集合的工具类,里面定义了很多静态方法用于操作集合.
Collections.sort(List list)方法
可以对List集合进行自然排序(从小到大)
package collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
/**
* 集合的排序
* 集合的工具类:java.util.Collections提供了一个静态方法sort,可以对List集合
* 进行自然排序
*/
public class SortListDemo1 {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
Random random = new Random();
for(int i=0;i<10;i++){
list.add(random.nextInt(100));
}
System.out.println(list);
Collections.sort(list);
System.out.println(list);
}
}
排序自定义类型元素
package collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* 排序自定义类型元素
*/
public class SortListDemo2 {
public static void main(String[] args) {
List<Point> list = new ArrayList<>();
list.add(new Point(1,2));
list.add(new Point(97,88));
list.add(new Point(7,6));
list.add(new Point(9,9));
list.add(new Point(5,4));
list.add(new Point(2,3));
System.out.println(list);
/*
编译不通过的原因:
Collections.sort(List list)该方法要求集合中的元素类型必须实现接口:
Comparable,该接口中有一个抽象方法compareTo,这个方法用来定义元素之间比较
大小的规则.所以只有实现了该接口的元素才能利用这个方法比较出大小进而实现排序
操作.
*/
Collections.sort(list);//编译不通过 compare比较 comparable可以比较的
System.out.println(list);
}
}
实际开发中,我们并不会让我们自己定义的类(如果该类作为集合元素使用)去实现Comparable接口,因为这对我们的程序有侵入性.
侵入性:当我们调用某个API功能时,其要求我们为其修改其他额外的代码,这个现象就是侵入性.侵入性越强的API越不利于程序的后期可维护性.应当尽量避免.
重载的Collections.sort(List list,Comparator c)方法
package collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
* 排序自定义类型元素
*/
public class SortListDemo2 {
public static void main(String[] args) {
List<Point> list = new ArrayList<>();
list.add(new Point(1,2));
list.add(new Point(97,88));
list.add(new Point(7,6));
list.add(new Point(9,9));
list.add(new Point(5,4));
list.add(new Point(2,3));
System.out.println(list);
/*
Collections.sort(List list)在排序List集合时要求集合元素必须实现了
Comparable接口。实现了该接口的类必须重写一个方法compareTo用与定义比较
大小的规则，从而进行元素间的比较后排序。否则编译不通过。
侵入性:
当我们调用某个API时，其反过来要求我们为其修改其他额外的代码，这种现象就
成为侵入性。侵入性不利于程序后期的维护，尽可能避免。
compare:比较
*/
// Collections.sort(list);
//匿名内部类的形式创建一个比较器
Comparator<Point> com = new Comparator<Point>() {
@Override
/**
* 实现比较器接口后必须重写方法compare.
* 该方法用来定义参数o1与参数o2的比较大小规则
* 返回值用来表示o1与o2的大小关系
*/
public int compare(Point o1, Point o2) {
int len1 = o1.getX() * o1.getX() + o1.getY() * o1.getY();
int len2 = o2.getX() * o2.getX() + o2.getY() * o2.getY();
return len1-len2;
}
};
Collections.sort(list,com);//回调模式
System.out.println(list);
}
}
最终没有侵入性的写法
package collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
* 排序自定义类型元素
*/
public class SortListDemo2 {
public static void main(String[] args) {
List<Point> list = new ArrayList<>();
list.add(new Point(1,2));
list.add(new Point(97,88));
list.add(new Point(7,6));
list.add(new Point(9,9));
list.add(new Point(5,4));
list.add(new Point(2,3));
System.out.println(list);
/*
Collections.sort(List list)在排序List集合时要求集合元素必须实现了
Comparable接口。实现了该接口的类必须重写一个方法compareTo用与定义比较
大小的规则，从而进行元素间的比较后排序。否则编译不通过。
侵入性:
当我们调用某个API时，其反过来要求我们为其修改其他额外的代码，这种现象就
称为侵入性。侵入性不利于程序后期的维护，尽可能避免。
compare:比较
*/
// Collections.sort(list);
//匿名内部类的形式创建一个比较器
// Comparator<Point> com = new Comparator<Point>() {
// @Override
// /**
// * 实现比较器接口后必须重写方法compare.
// * 该方法用来定义参数o1与参数o2的比较大小规则
// * 返回值用来表示o1与o2的大小关系
// */
// public int compare(Point o1, Point o2) {
// int len1 = o1.getX() * o1.getX() + o1.getY() * o1.getY();
// int len2 = o2.getX() * o2.getX() + o2.getY() * o2.getY();
// return len1-len2;
// }
// };
// Collections.sort(list,com);//回调模式
// Collections.sort(list,new Comparator<Point>() {
// public int compare(Point o1, Point o2) {
// int len1 = o1.getX() * o1.getX() + o1.getY() * o1.getY();
// int len2 = o2.getX() * o2.getX() + o2.getY() * o2.getY();
// return len1-len2;
// }
// });
Collections.sort(list,(o1,o2)->
o1.getX() * o1.getX() + o1.getY() * o1.getY() -
o2.getX() * o2.getX() - o2.getY() * o2.getY()
);
System.out.println(list);
}
}
排序字符串
java中提供的类,如:String,包装类都实现了Comparable接口,但有时候这些比较规则不能满足我们的排序需求时,同样可以临时提供一种比较规则来进行排序.
package collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class SortListDemo3 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
// list.add("Tom");
// list.add("jackson");
// list.add("rose");
// list.add("jill");
// list.add("ada");
// list.add("hanmeimei");
// list.add("lilei");
// list.add("hongtaoliu");
// list.add("Jerry");
list.add("传奇");
list.add("小泽老师");
list.add("苍老师");
System.out.println(list);
//按照字符多少排序
// Collections.sort(list);
// Collections.sort(list, new Comparator<String>() {
// public int compare(String o1, String o2) {
return o1.length()-o2.length();
// return o2.length()-o1.length();//反过来减就是降序
// }
// });
Collections.sort(list,(o1,o2)->o2.length()-o1.length());
System.out.println(list);
}
}
3709
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
