java.util.Collection接口 集合接口 该接口是所有集合的顶级接口,规定了所有集合都必须具备的操作. 集合与数组一样,可以保存一组元素,并且对于元素的相关操作都提供成了方法,使用方便. 集合有多种不同的数据结构可供使用. Collection下面有两个常见的子接口(常见分类) java.util.List:可重复且有序的集合 java.util.Set:不可重复的集合 所谓重复指的是元素是否重复,而重复的依据是元素自身equals方法比较是否为true 如果为true则认为是重复元素,Set集合不允许存入重复的元素. boolean add(E e) 向当前集合中添加一个元素 注意:集合只能存放引用类型元素!!!! 返回值表示该元素是否成功添加到集合中,如果成功添加则返回true否则为false int size() 返回的是当前集合的元素个数 boolean isEmpty() 判断当前集合是否为一个空集 当且仅当size=0时,isEmpty返回值为true void clear() 清空集合
public class CollectionDemo1 {
public static void main(String[] args) {
Collection c = new ArrayList();
/*
boolean add(E e)
向当前集合中添加一个元素
注意:集合只能存放引用类型元素!!!!
返回值表示该元素是否成功添加到集合中,如果成功添加则返回true否则为false
*/
c.add("one");
c.add("two");
c.add("three");
c.add("four");
c.add("five");
// c.add(123);//触动自动装箱特性,变成Integer(引用类型)
System.out.println(c);
/*
int size()
返回的是当前集合的元素个数
*/
int size = c.size();
System.out.println("size:"+size);
/*
boolean isEmpty()
判断当前集合是否为一个空集
当且仅当size=0时,isEmpty返回值为true
*/
boolean isEmpty = c.isEmpty();
System.out.println("是否为空集:"+isEmpty);
/*
void clear()
清空集合
*/
c.clear();
System.out.println(c);
System.out.println("size:"+c.size());//重新获取的
System.out.println("isEmpty:"+c.isEmpty());
}
}Point：点
使用当前类作为集合元素，测试集合相关操作
import java.util.Objects;
/**
* 使用当前类作为集合元素测试集合相关操作
*/
public class Point {
private int x;
private int y;
public Point(){}
public Point(int x, int y) {
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
@Override
public String toString() {
return "Point{" +
"x=" + x +
", y=" + y +
'}';
}
@Override
public boolean equals(Object o) {//被依靠remove,contain
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Point point = (Point) o;
return x == point.x && y == point.y;
}
@Override
public int hashCode() {
return Objects.hash(x, y);
}
}元素equals方法会影响集合的一些操作.比如判断是否为重复元素.还有contains包含,remove删除元素等操作也是依靠该方法的. contains:包含 boolean contains(Object o) 判断当前集合是否包含给定元素,若包含则返回true 判断包含的标准:当前集合里是否含有与给定元素equals比较true的元素. 如果存在则认为包含. remove:移除 boolean remove(Object obj) 从集合中删除与给定元素equals比较为true的元素 如果集合中存在多个这样的元素,仅会删除一个.
import java.util.ArrayList;
import java.util.Collection;
/**
* 元素equals方法会影响集合的一些操作.比如判断是否为重复元素.还有包含,删除元素等操作
* 也是依靠该方法的.
*/
public class CollectionDemo2 {
public static void main(String[] args) {
Collection c = new ArrayList();
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(9,10));
c.add(new Point(1,2));
/*
当我们输出一个集合时,实际输出的是该集合toString方法的返回值
集合重写了toString方法,格式为:
[元素1.toString(), 元素2.toString(), ...]
*/
System.out.println(c);
/*
contains:包含
boolean contains(Object o)
判断当前集合是否包含给定元素,若包含则返回true
判断包含的标准:当前集合里是否含有与给定元素equals比较true的元素.
如果存在则认为包含.
*/
Point p = new Point(1,2);
boolean contains = c.contains(p);
System.out.println("包含:"+contains);
/*
boolean remove(Object obj)
从集合中删除与给定元素equals比较为true的元素
如果集合中存在多个这样的元素,仅会删除一个.
*/
c.remove(p);
System.out.println(c);
}
}集合只能存放引用类型元素,并且存放的是元素的引用(地址)
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);
System.out.println("c:"+c);
p.setX(2);
System.out.println("p:"+p);
System.out.println("c:"+c);//(?,2)地址的传递
}
}集合间的操作 boolean addAll(Collection c) 将给定集合所有元素添加到当前集合中. 注意:如果当前集合是Set集合,则重复的元素是不能放进来两次的. 返回值:添加后当前集合发生了变化则返回true boolean containsAll(Collection c); 判断当前集合是否包含给定集合中的所有元素. retainAll()取交集,保留当前集合中与给定集合的共有元素. removeAll()删交集,删除当前集合中与给定集合的共有元素
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
public class CollectionDemo4 {
public static void main(String[] args) {
//HashSet是最常用的Set集合实现类.
Collection c1 = new HashSet();
c1.add("java");
c1.add(".net");
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)
将给定集合所有元素添加到当前集合中.
注意:如果当前集合是Set集合,则重复的元素是不能放进来两次的.
返回值:添加后当前集合发生了变化则返回true
*/
c1.addAll(c2);
System.out.println("c1:"+c1);
System.out.println("c2:"+c2);
Collection c3 = new ArrayList();
c3.add("java");
c3.add("ios");
c3.add("php");
System.out.println("c3:"+c3);
/*
boolean containsAll(Collection c);
判断当前集合是否包含给定集合中的所有元素.
*/
boolean containsAll = c1.containsAll(c3);
System.out.println("全包含:"+containsAll);
/*
取交集,保留当前集合中与给定集合的共有元素.
*/
// c1.retainAll(c3);
// System.out.println("c1:"+c1);
/*
删交集,删除当前集合中与给定集合的共有元素
*/
c1.removeAll(c3);
System.out.println("c1:"+c1);
}
}java.util.List List表示的是可重复且有序的集合。也称为"线性表" List常用的实现类: java.util.ArrayList:内部使用数组实现，查询性能更好。 java.util.LinkedList:内部使用链表实现，增删性能更好，首尾增删元素最佳。 在对性能没有特别苛刻的要求时，首选使用ArrayList E get(int index) 获取指定位置上的元素 E set(int index,E e) 将给定元素e设置到指定位置index处 返回值就是被替换下来的元素 集合的反转
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class ListDemo1 {
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);
/*
E get(int index)
获取指定位置上的元素
*/
String str = list.get(2);//array[2];
System.out.println(str);
for(int i=0;i<list.size();i++){
str = list.get(i);
System.out.println(str);
}
/*
E set(int index,E e)
将给定元素e设置到指定位置index处
返回值就是被替换下来的元素
*/
//[one,two,six,four,five]
String old = list.set(2,"six");
System.out.println(list);
System.out.println(old);
//集合反转
// v v
//[five,four,six,two,one]
// 0 1 2 3 4
// Collections.reverse(list);{可以这样，简单粗暴}
for(int i=0;i<list.size()/2;i++){
//获取正数位置元素
String s = list.get(i);
//将该元素设置到倒数位置上并获取该倒数位置的元素
s = list.set(list.size()-1-i,s);
//再将倒数位置的元素设置到正数位置上
list.set(i,s);
}
System.out.println(list);
}
}List提供了一对重载的add,remove方法 void add(int index,E e) 将给定元素e添加到指定下标index位置处 E remove(int index) 删除并返回指定位置上的元素
import java.util.ArrayList;
import java.util.List;
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)
将给定元素e添加到指定下标index位置处
*/
//[one,two,three,six,four,five]
list.add(3,"six");
System.out.println(list);
/*
E remove(int index)
删除并返回指定位置上的元素
*/
//[one,two,six,four,five]
//删除集合中第三个元素
String old = list.remove(2);
System.out.println(list);
System.out.println("被删除的元素是:"+old);
}
}List subList(int start,int end) 获取当前集合中指定范围内的子集。两个参数为开始下标和结束下标的位置。含头不含尾 对子集的操作就是对原集合对应的操作。
import java.util.ArrayList;
import java.util.List;
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);
List<Integer> subList = list.subList(3,8);
System.out.println(subList);
//将子集每个元素扩大10倍
// for(int i=0;i<subList.size();i++){
// int num = subList.get(i);
// num = num * 10;
// subList.set(i,num);
// }
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
for (int i = 2; i < 9; i++) {
// list.remove(i);
list.remove(2);//删除之后在之后的基础上删除
}
list.subList(2,9).clear();
System.out.println(list);
}
}集合与数组互转
List.toArray(new String[]);//集合转数组
重载的toArray方法要求我们传入一个数组(需要转换为什么类型的数组
就应当传入一个什么类型的数组，但是需要注意该类型应当与当前集合的
泛型一致,即元素类型一致)。
传入的数组长度没有限制，toArray方法如果判断传入的数组可用就直接
将集合元素存入该数组后将其返回(当数组长度>=集合的size)否则直接
创建一个与集合size一样长的数组。
Arrays.asList(数组)；//数组转集合
数组的工具类:java.util.Arrays有一个静态方法asList,可以将一个
数组转换为一个List集合.
由于数组是定长的,所以该集合任何会修改长度的操作都是不支持的,会抛出异常
java.lang.UnsupportedOperationException(不支持的操作异常)
list.add("!!!");
如果希望对集合进行增删等操作,那么只能自行再创建一个集合并包含该集合
中的所有元素
所有的集合都支持一个参数类型为Collection的构造方法,作用是创建当前
集合的同时包含给定集合中的所有元素.
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
public class CollectionToArrayDemo {
public static void main(String[] args) {
Collection<String> c = new ArrayList<>();
c.add("one");
c.add("two");
c.add("three");
c.add("four");
c.add("five");
System.out.println(c);
//返回对象数组的toArray现在用的非常少了，不方便。
// Object[] array = c.toArray();
/*
重载的toArray方法要求我们传入一个数组(需要转换为什么类型的数组
就应当传入一个什么类型的数组，但是需要注意该类型应当与当前集合的
泛型一致,即元素类型一致)。
传入的数组长度没有限制，toArray方法如果判断传入的数组可用就直接
将集合元素存入该数组后将其返回(当数组长度>=集合的size)否则直接
创建一个与集合size一样长的数组。
*/
String[] array = c.toArray(new String[c.size()]);//集合转数组
// String[] array = c.toArray(new String[10]);
// String[] array = c.toArray(new String[1]);
System.out.println(Arrays.toString(array));
/*数组的工具类:java.util.Arrays有一个静态方法asList,可以将一个
数组转换为一个List集合.*/
List<String> list = Arrays.asList(array);//数组转集合
System.out.println("list:"+list);
//添加元素时要重新建立，不然数组的增加或删除都会直接影响到集合
//list2.addAll(list1)
List<String> list2 = new ArrayList<>(list);
list2.add("!!!");
System.out.println("list2:"+list2);
}集合的排序
当集合元素已经实现了Comparable接口并定义了比较规则,但是这个规则不能满足我们的 排序需求时,我们也可以临时指定一个规则进行排序 例如:排序字符串
Collections.sort(集合)；//排序
Collections.shuffle(集合)；//乱序
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
public class SortListDemo {
public static void main(String[] args) {
Random random = new Random();
List<Integer> list = new ArrayList<>();
for(int i=0;i<10;i++){
list.add(random.nextInt(100));
}
System.out.println(list);
Collections.sort(list);//排序
System.out.println(list)；
Collections.sort(list,(i1,i2)->i2-i1);//降序
System.out.println(list);
Collections.shuffle(list);//乱序
System.out.println(list);
}
}排序自定义类型元素的集合 compare:比较 comparable:可比较的 Collections在排序一个List集合时,要求集合元素必须实现Comparable 接口,否则编译不通过. 该操作不推荐使用,因为对我们的代码有侵入性! 侵入性: 当我们使用某个API时,其要求我们为其修改其他额外地方的代码,就是侵入性 它不利于程序后期的维护.
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(9,8));
list.add(new Point(0,3));
list.add(new Point(5,4));
list.add(new Point(12,23));
list.add(new Point(14,8));
System.out.println(list);
/*
compare:比较
comparable:可比较的
Collections在排序一个List集合时,要求集合元素必须实现Comparable
接口,否则编译不通过.
该操作不推荐使用,因为对我们的代码有侵入性!
侵入性:
当我们使用某个API时,其要求我们为其修改其他额外地方的代码,就是侵入性
它不利于程序后期的维护.
*/
// Collections.sort(list);
// Comparator<Point> c = new Comparator<Point>() {
// /*
// 该方法重写的目的用于给出o1与o2谁大谁小.
// 返回值是一个int值,表达o1与o2的大小关系.
// 当返回值>0时:表示经过判断o1是大于o2的
// 当返回值<0时:表示o1<o2
// 当返回值=0时:表示o1与o2相等
// */
// public int compare(Point o1, Point o2) {
// int olen1 = o1.getX()*o1.getX()+o1.getY()*o1.getY();
// int olen2 = o2.getX()*o2.getX()+o2.getY()*o2.getY();
// return olen1-olen2;
// }
// };
// Collections.sort(list,c);
// Collections.sort(list,new Comparator<Point>() {
// public int compare(Point o1, Point o2) {
// int olen1 = o1.getX()*o1.getX()+o1.getY()*o1.getY();
// int olen2 = o2.getX()*o2.getX()+o2.getY()*o2.getY();
// return olen1-olen2;
// }
// });
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);
}
}
2966
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
