容器2

最新推荐文章于 2021-03-17 22:41:39 发布

好来污最佳男主角

最新推荐文章于 2021-03-17 22:41:39 发布

阅读量206

点赞数

文章标签： java

本文链接：https://blog.csdn.net/Hello_zbs/article/details/105325119

版权

容器操作

1.Collection工具类
类 java.util.Collections 提供了对容器操作的工具方法，与 Arrays 使用差不多。
2.常用方法

void sort(List) //对 List 容器内的元素排序,按照升序进行排序。 
void shuffle(List) //对 List 容器内的元素进行随机排列 
void reverse(List) //对 List 容器内的元素进行逆续排列 
void fill(List, Object) //用一个特定的对象重写整个 List 容器 
int binarySearch(List, Object)//采用折半查找的方法查找特定对象 
List aList = new ArrayList(); 
for (int i = 0; i < 5; i++) 
aList.add("a" + i); 
System.out.println(aList); 
Collections.shuffle(aList); // 随机排列 
System.out.println(aList); 
Collections.reverse(aList); // 逆续 
System.out.println(aList); 
Collections.sort(aList); // 排序 
System.out.println(aList); 
System.out.println(Collections.binarySearch(aList, "a2")); 
Collections.fill(aList, "hello"); 
System.out.println(aList);

3.Comparable接口
Comparable接口中只有一个方法
public int compareTo(Object obj);
该方法:
返回 0 表示 this == obj
返回正数表示 this > obj
返回负数表示 this < obj
实现了Comparable 接口的类通过实现 comparaTo 方法从而确定该类对象的排序方式。
4.Comparator 接口
Comparator比较器，可以根据需要定制特定的比较规则

List<Student> stus = new ArrayList<Student>(){ 
{ 
add(new Student("张三", 30)); 
add(new Student("李四", 20)); 
add(new Student("王五", 60)); 
} 
};
//对users按年龄进行排序 
Collections.sort(stus, new Comparator<Student>() { 
@Override 
public int compare(Student s1, Student s2) { 
// 升序 
//return s1.getAge()-s2.getAge(); 
return s1.getAge().compareTo(s2.getAge()); 
// 降序 
// return s2.getAge()-s1.getAge(); 
// return s2.getAge().compareTo(s1.getAge()); 
} 
});

还可以使用lambda表达式简化代码, 前提是JDK8开发环境,

List<Student> stus = new ArrayList<Student>(){ 
{ 
add(new Student("张三", 30)); 
add(new Student("李四", 20)); 
add(new Student("王五", 60)); 
} 
};
//对users按年龄进行排序 
Collections.sort(stus, (s1,s2)->(s1.getAge()-s2.getAge()));

Stream的操作三个步骤

stream 是数据渠道，用于操作数据源（集合、数组）所生产的元素序列。
1、创建Stream
一个数据源（如：集合、数组），获取一个流
2、中间操作
一个中间操作链，对数据源的数据进行处理
3、终止操作
一个终止操作，执行中间操作链，并产生结果
创建Stream

/*** StreamAPI三个操作步骤： 
* 1、创建Stream 
* 2、中间操作 
* 3、终止操作 
*/ 
public class TestStreamAPI1 { 
// 创建Stream 
 @Test 
 public void test1() { 
  // 1、可以通过Conllection系列集合提供的顺序流stream()或并行流parallelStream() 
 List<String> list = new ArrayList<>(); 
 Stream<String> stream1 = list.stream(); 
 stream1 = list.parallelStream(); 
 // 2、通过Arrays中的静态方法stream()获取数据流 
 Integer ints[] = new Integer[10]; 
  Stream<Integer> stream2 = Arrays.stream(ints); 
 // 3、通过Stream类中的静态方法of() 
 Stream<String> stream3 = Stream.of("aa", "bb", "cc"); 
 String str[] = new String[10]; 
 Stream<String> stream4 = Stream.of(str) 
 } 
 }

Stream的中间操作

多个中间操作可以连接起来形成一个流水线,除非流水线上触发终止操作,否则中间操作不会执行任何的处理,而在终止操作时一次性全部处理,称为”惰性求值”.
筛选和切片
filter

List<Employee> emps = Arrays.asList( 
new Employee("张三", 18, 3333.33), 
new Employee("李四", 38, 4444.44), 
new Employee("王五", 50, 5555.55), 
new Employee("赵六", 16, 6666.66), 
new Employee("田七", 28, 7777.77) );
// filter-接收Lambda，从流中排除某些元素 
@Test 
public void test1() { 
Stream<Employee> stream = emps.stream() .filter((e) -> { 
System.out.println("StreamAPI的中间操作"); 
return e.getAge() > 35;
}); 
// 终止操作：一次性执行全部内容，即“惰性求值” 
stream.forEach(System.out::println); }

limit

// limit-截断流，使其元素不超过给定数量
@Test 
public void test2() { 
emps.stream() .filter((e) -> e.getSalary() > 5000) 
.limit(2) 
.forEach(System.out::println); 
}

skip

// skip-跳过元素，返回一个扔掉了前n个元素的流，若流中元素不足n个，则返回一个空流。 
@Test 
public void test3() { 
emps.stream() .filter((e) -> e.getSalary() > 5000) 
.skip(2) 
.forEach(System.out::println); 
}

distinct

// distinct-筛选，通过流所生产元素的hashCode()和equals()去除重复元素 
@Test 
public void test4() { 
emps.stream() .filter((e) -> e.getSalary() > 5000) 
.distinct() 
.forEach(System.out::println); }

排序

sorted(Comparable)-自然排序

// sorted(Comparable)-自然排序 
@Test 
public void test1() { 
List<String> list = Arrays.asList("cc", "aa", "bb", "ee", "dd"); 
list.stream() 
.sorted() 
.forEach(System.out::println); 
}

sorted(Comparator)-定制排序

// sorted(Comparator)-定制排序 
// 需求：按年龄排序，年龄一样按姓名排序 
@Test 
public void test2() { 
emps.stream() .sorted((e1, e2) -> { 
if(e1.getAge().equals(e2.getAge())) { 
return e1.getName().compareTo(e1.getName()); 
}else { 
return e1.getAge().compareTo(e2.getAge()); 
} 
}).forEach(System.out::println); }

终止操作

查找于匹配

public void test1() {
// allMatch-检查是否匹配所有元素 
boolean b1 = emps.stream() .allMatch((e) -> e.getStatus().equals(Status.BUSY)); System.out.println(b1); 
// anyMatch-检查是否至少匹配一个元素 
boolean b2 = emps.stream() .anyMatch((e) -> e.getStatus().equals(Status.BUSY)); System.out.println(b2); 
// noneMatch-检查是否没有匹配所有元素 
boolean b3 = emps.stream() .noneMatch((e) -> e.getStatus().equals(Status.OTHER)); System.out.println(b3); 
// findFirst-返回第一个元素 
// 需求：按工资排序，获取第一个员工信息 
Optional<Employee> op1 = emps.stream() .sorted((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())) .findFirst(); 
System.out.println(op1.get()); 
// findAny-返回当前流中的任意元素 
// 需求：找一个空闲状态的员工，添加到开发团队中 
Optional<Employee> op2 = emps.parallelStream
// 并行流-多条线程进行，谁先找到就是谁 .filter((e) -> e.getStatus().equals(Status.FERR)) .findAny(); 
System.out.println(op2.get()); 
// count-返回流中元素的总个数 
Long count = emps.stream().count(); 
System.out.println(count); 
// max-返回流中最大值 
// 需求：获取工资最高的员工信息 
Optional<Employee> op3 = emps.stream() .max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())); 
System.out.println(op3.get()); 
// min-返回流中最小值 
// 需求：获取公司中工资最少员工的工资 
Optional<Double> op4 = emps.stream() .map(Employee::getSalary) .min(Double::compare); System.out.println(op4.get()); }