java.util.Collection List API
原创
简介
java.util.Collection是一个集合框架的父接口。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。
List<String> list = new ArrayList();
List<String> linkedList = new LinkedList();
List<String> vector = new Vector();1.使用Collections.addAll()方法，前提还是需要手动new ArrayList
ArrayList<String> s = new ArrayList();
Collections.addAll(s, "1", "2", "3")
2.使用Arrays.asList(...args) 直接返回一个List
List<String> s = Arrays.asList("1","2","3")
3.如果引入了Guava的工具包，可以使用他的Lists.newArrayList(...args)方法
List<String> list = Lists.newArrayList("1", "2", "3")
4.如果是Java9，可以使用自带的List类
List<String> s = List.of("1", "2", "3")add
描述：在指定位置插入元素，后面的元素都往后移一个元素。
void add(int index, E element)addAll
描述：在指定的位置中插入c集合全部的元素，如果集合发生改变，则返回true，否则返回false。意思就是当插入的集合c没有元素，那么就返回false，如果集合c有元素，插入成功，那么就返回true。
boolean addAll(int index, Collection<? extends E> c)get
描述：返回list集合中指定索引位置的元素
E get(int index)indexOf
描述：返回list集合中第一次出现o对象的索引位置，如果list集合中没有o对象，那么就返回-1。
int indexOf(Object o)listIterator
描述：返回此列表元素的列表迭代器（按适当顺序）。
ListIterator<E> listIterator()描述：从指定位置开始，返回此列表元素的列表迭代器（按适当顺序）。
ListIterator<E> listIterator(int index)remove
描述：删除指定索引的对象
E remove(int index)set
描述：在索引为index位置的元素更改为element元素
E set(int index, E element)subList
描述：返回从索引fromIndex到toIndex的元素集合，包左不包右。
ArrayList的subList 结果不可强转成ArrayList，否则会抛出ClassCastException异常，即java.util.RandomAccessSubList cannot be cast to java.util.ArrayList。
源码：ArrayList类
public List<E> subList(int fromIndex, int toIndex) {
subListRangeCheck(fromIndex, toIndex, size);
return new SubList(this, 0, fromIndex, toIndex);
}说明：subList 返回的是 ArrayList 的内部类 SubList，并不是 ArrayList 而是 ArrayList 的一个视图，对于 SubList 子列表的所有操作最终会反映到原列表上。
方法一：
public class Test {
public static void main(String[] args) {
List<Integer> list=new ArrayList<>();
for (int i = 1; i <= 323; i++) {
list.add(i);
}
int perCount=100,index=1;
int times=list.size()/perCount;
System.out.println("time:" + times);
do {
List<Integer> listTemp=null;
if(list.size()>=perCount){
listTemp=list.subList(0, perCount);// listTemp是分段处理逻辑的参数
}else{
listTemp=list.subList(0, list.size());// listTemp是分段处理逻辑的参数
}
//遍历当前的值是否正确
String result="";
for (int i = 0; i < listTemp.size(); i++) {
result+=listTemp.get(i)+",";
}
System.out.println("第"+index+"轮:>>"+result);
list.removeAll(listTemp);
System.out.println("当前剩余集合长度:>>"+list.size());
index++;
}
while (index<=times+1);
}
}
方法二：
public static void subList() {
int SIZE_5 = 5;
// 初始化list数据
List<Integer> list = Lists.newArrayList();
for(int i=0; i < 12; i++){
list.add(i);
}
System.out.println("原始list："+list);
// 分批获取(每5个元素获取一个子集合)
for(int i=0; i < list.size()/SIZE_5+1; i++){
int fromIndex = i * SIZE_5;
int toIndex = Math.min(fromIndex + SIZE_5, list.size());
List<Integer> subList = list.subList(fromIndex, toIndex); // 注意:这里可能出现List为空的情况，所以下面需要有对List集合的判断
if(CollectionUtils.isNotEmpty(subList)){
System.out.println(subList);
}
}
}工具方法
diff
描述：对比两个List集合中的差集
/**
* 返回两个集合的差集
* @param list1
* @param list2
* @return
*/
private static List<String> getDiffrent4(List<String> list1, List<String> list2) {
List<String> diff = new ArrayList<>();
Map<String, Integer> map = new HashMap<String, Integer>(list1.size() + list2.size());
List<String> maxList = list1;
List<String> minList = list2;
if (list2.size() > list1.size()) {
maxList = list2;
minList = list1;
}
for (String string : maxList) {
map.put(string, 1);
}
for (String string : minList) {
Integer count = map.get(string);
if (count != null) {
map.put(string, ++count);
continue;
}
map.put(string, 1);
}
for (Map.Entry<String, Integer> entry : map.entrySet()) {
if (entry.getValue() == 1) {
diff.add(entry.getKey());
}
}
return diff;
}sort
1. 整数List排序
List<Integer> numbers = Arrays.asList(6, 2, 1, 4, 9);
System.out.println(numbers); //[6, 2, 1, 4, 9]
numbers.sort(Comparator.naturalOrder()); //自然排序
System.out.println(numbers); //[1, 2, 4, 6, 9]
numbers.sort(Comparator.reverseOrder()); //倒序排序
System.out.println(numbers); //[9, 6, 4, 2, 1]3. 字符串List排序
说明：cities是一个字符串数组。注意london的首字母是小写的。
List<String> cities = Arrays.asList(
"Milan",
"london",
"San Francisco",
"Tokyo",
"New Delhi"
);
System.out.println(cities);
//[Milan, london, San Francisco, Tokyo, New Delhi]
cities.sort(String.CASE_INSENSITIVE_ORDER); // 字母大小写不敏感
System.out.println(cities);
//[london, Milan, New Delhi, San Francisco, Tokyo]
cities.sort(Comparator.naturalOrder()); // 字母自然顺序排序
System.out.println(cities);
//[Milan, New Delhi, San Francisco, Tokyo, london]4. 对象字段List<Object>排序
Employee e1 = new Employee(1,23,"M","Rick","Beethovan");
Employee e2 = new Employee(2,13,"F","Martina","Hengis");
Employee e3 = new Employee(3,43,"M","Ricky","Martin");
Employee e4 = new Employee(4,26,"M","Jon","Lowman");
Employee e5 = new Employee(5,19,"F","Cristine","Maria");
Employee e6 = new Employee(6,15,"M","David","Feezor");
Employee e7 = new Employee(7,68,"F","Melissa","Roy");
Employee e8 = new Employee(8,79,"M","Alex","Gussin");
Employee e9 = new Employee(9,15,"F","Neetu","Singh");
Employee e10 = new Employee(10,45,"M","Naveen","Jain");
List<Employee> employees = Arrays.asList(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10);
employees.sort(Comparator.comparing(Employee::getAge));
employees.forEach(System.out::println);
如果我们希望List按照年龄age的倒序排序，就使用reversed()方法。如：
employees.sort(Comparator.comparing(Employee::getAge).reversed());5. Comparator链对List<Object>排序
下面这段代码先是按性别的倒序排序，再按照年龄的倒序排序。
employees.sort(
Comparator.comparing(Employee::getGender)
.thenComparing(Employee::getAge)
.reversed()
);
employees.forEach(System.out::println);
//都是正序 ，不加reversed
//都是倒序，最后面加一个reserved
//先是倒序（加reserved），然后正序
//先是正序（加reserved），然后倒序（加reserved）原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。
如有侵权，请联系 cloudcommunity@tencent.com 删除。
原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。
如有侵权，请联系 cloudcommunity@tencent.com 删除。
评论
登录后参与评论
推荐阅读
目录