java学习（8）（Lambda表达式，泛型，集合）

kangnano1

已于 2024-05-12 17:34:36 修改

阅读量1.8k

点赞数 61

分类专栏： java学习文章标签： java 学习

于 2024-05-12 17:32:51 首次发布

本文链接：https://blog.csdn.net/2201_75508405/article/details/138760627

版权

java学习专栏收录该内容

9 篇文章 0 订阅

订阅专栏

Lambda表达式

Lambda表达式是可以传递给方法的一段代码，可以是一个语句，也可以是一个代码块。

Lambda表达式的语法

（参数1，参数2，....）->表达式；

（参数1，参数2，....）->{//代码块}；

如果表达式只包含一个语句，语句块的大括号可以省略。
如果Lambda表达式没有参数，则仍然需要提供一对空的小括号。
如果Lambda表达式的参数类型是可以推导的，那么还可以省略它们的类型。
如果某个方法只含一个参数，并且该参数的类型可以被推到出来，则参数的小括号也可以省略。

函数式接口

函数式接口是指仅包含一个抽象方法的接口，也称单抽象方法接口，函数式接口中可以定义默认方法。
每一个Lambda表达式都对应一个函数式接口类型，可以将Lambda表达式看作实现函数式接口的类的一个实例。
在定义函数式接口时可以给接口添加@FunctionInterface注解，如果接口定义多于一个的抽象方法，编译器会报错。

泛型

泛型是带一个或多个类型参数的类或接口。

泛型类型本身是一个java类型。

public class Node<T>{
    private T value;//泛型成员
    public Node(){}//默认构造方法
    public Node(T value){//带参数构造方法
        this.value = value;     
    }
    public T get(){//访问方法定义
        return value;
    }
    public void set(T value){//修改方法定义
        this.value = value;
    }
    //显示类型名
    public void showType(){
        System.out.println("T的类型是："+value.getClass().getName());
    }
}

T为一种特殊类型的变量，它可以是任何类或接口，但不能是基本数据类型，T可以看作是Node类的一个形式参数，泛型也被称为参数化类型。

使用泛型需传递一个类型参数，即用某个具体的类型替换T。要实例化泛型类对象要使用new运算符。

泛型可能具有多个类型参数，但类或接口的声明中，每个参数名必须是唯一的。

Node<Integer> intNode = new Node<>();

类型参数名使用单个大写字母表示。

E（表示元素）、K（表示键）、N（表示数字）、T（表示类型）、V（表示值）

泛型方法

泛型方法是带类型参数的方法。类的成员方法和构造方法都可以定义为泛型方法，但类型参数的作用域仅限于声明的方法和构造方法内。

泛型方法可以定义为静态的和非静态的。

对于泛型方法必须在方法返回值前指定泛型。

public class Util{
    public static <T> void swap(T[] array,int i,int j){
        T temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}
public static void main(String[] args){
    Integer[] numbers={1,3,5,7};
    Util.<Integer>swap(numbers,0,3);
    for(Integer n:numbers){
        System.out.println(n+"");
    }
}

通配符（?）的使用

List<Object> list1 = new ArrayList<Object>();
List<String> list2 = new ArrayList<String>();
public static void printList(List<?> list){//?就是通配符，表示该方法可接受的元素是任何类型的List对象
    for(Object element:list){
        System.out.println(element);
    }
}

有界类型参数

有界类型分为上界和下界，上界用extends指定，下界用super指定。

extends具有一般的意义，对类表示扩展，对接口表示实现。

List<? extends Number> numberList
//参数为Number类或其子类的某种类型
List<? super Integer> integerList
//参数为Integer类型或其父类型的某种类型

public static double getAverage(List<? extends Number> numberList){
    //......
}

集合框架

集合是指集中存放一组对象的一个对象。

集合都是泛型类型。

java集合框架由两种类型构成，一个是Collection，另一个是Map。Collection对象用于存放一组对象，Map对象用于存放一组“关键字/值”的对象。

Collection<E>接口是所有集合接口的根接口，继承了Iterable<E>接口。它有三个爱接口：Set接口、List接口、Queue接口。

Collection接口定义了集合操作的常用方法。

基本操作

boolean add(E e):向集合中添加元素e。
boolean remove(Object o):从集合中删除指定的元素o。
boolean contains(Object o): 返回集合中是否包含指定的元素o。
boolean isEmply():返回集合是否为空。
int size():返回集合中包含的元素个数。
Iterator iterator():返回包含所有元素的迭代器对象。
default void forEach(Consumer<? super T> action):从父接口继承的方法，在集合的每个元素上执行指定的操作。

批量操作

boolean addAll(Collection<? extends E> c):将集合c中的所有元素添加到当前集合中。
boolean removeAll(Collection<?> c):从当前集合中删除c中所有元素。
default boolean removeIf(Predicate<? super E> filter):从当前集合中删除满足谓词的所有元素。
boolean containsAll(Collection<?> c):返回当前集合是否包含c中的所有元素。
boolean retainAll(Collection<?> c):在当前集合中只保留指定集合c中的元素，其他元素删除。
void clear():将集合清空。

数组操作

将集合元素转换为数组元素。

Object[] toArray():返回包含集合中所有元素的对象数组。
<T> T[] toArray(T[] a):返回包含集合中所有元素的数组，返回数组的元素类型是指定的数组类型。

流（Stream）操作方法

public default Stream<E> stream():以当前集合作为源返回一个顺序Stream对象。
public default Stream<E> paralellStream():以当前集合作为源返回一个并行Stream对象。

List接口

实现一种线性表的数据结构，List中可以包含重复元素，可以从0开始通过下标访问List中的元素。

List接口的实现类包括ArrayList、LinkedList、Vector、Stack。

E get(int index):返回指定下标处的元素。
E set(int index,E element):修改指定下标处的元素。
void add(int index,E element):将指定元素插入到指定下标处。
E remove(int index):删除指定下标处的元素。
abstract boolean addAll(int index,Collection<? extends E> c):在指定下标处插入集合c中的全部元素。
int indexOf(Object o):查找指定对象第一次出现的位置。
int lastIndexOf(Object o):查找指定对象最后一次出现的位置。
List<E> subList(int form,int to):返回从form到to元素的一个子线性表。
default void replaceAll(UnaryOperator<E> opeator):将操作符应用于元素，并使用其结果替代每个元素。

ArrayList类

ArrayList是最常用的线性表实现类，通过数组实现的集合对象。

ArrayList类实际上实现了一个变长的对象数组，其元素可以动态地增加和删除。

//ArrayList构造方法
ArrayList():创建一个空地数组线性表对象，默认初始容量是10。当线性表填满而又需要添加更多元素时，线性表大小会自动增大。
ArrayList(Collection c):用集合c中的元素创建一个数组线性表对象。
ArrayList(int initialCapacity):创建一个空的数组线性表对象，并指定初始容量。

遍历集合元素

简单的for循环
增强的for循环
```
for(String city:bigCities){
    System.out.println(city);
}
```
如果只是简单输出每个元素，可以调用集合对象的forEach()方法，传递一个System.out::println方法引用。
```
bigCities.forEach(System.out::println);
```
Interator迭代器

迭代器是一个可以遍历集合中的每个元素的对象。调用集合对象的iterator()方法可以得到Iterator对象，再调用Interator对象的方法就可以遍历集合中的每个元素。

//Iterator接口的方法
boolean hasNext():返回迭代器中是否还有对象。
E next():返回迭代器中下一个对象。
void remove():删除迭代器中的当前对象。

Iterator iterator = myList.iterator();
while(iterator.hasNext()){
    System.out.println(iterator.next());
}

双向迭代器

List还提供了listIterator()方法返回ListIterator对象，它可以从前后两个方向遍历线性表中的元素。ListIterator是Iterator的子接口。

使用迭代器可以修改线性表中的元素，但不能同时使用两个迭代器修改一个线性表中的元素。

boolean hasNext():返回是否还有下一个元素。
E next():返回下一个元素。
boolean hasPrevious():返回是否还有前一个元素。
E previous():返回前一个元素。
int nextIndex():返回下一个元素的索引。
int previousIndex():返回前一个元素的索引。
void remove():删除当前元素。
void set(E o):修改当前元素。
void add(E o):在当前位置插入一个元素。

数组转换为List对象

java.util.Arrays类提供了asList()方法

public static <T> List<T> asList(T...a)

String[] str = {"one","two","three","four"};
List<String> list = Arrays.asList(str);
System.out.println(list);

数组还可以使用基本数据类型，如果使用基本数据类型，则转换成List对象元素时进行了自动装箱操作。

Arrays.asList()方法返回的List对象是不可变的，不能进行添加，删除等操作。

//通过构造方法实现对List对象的操作
List<String> list = new ArrayList<>(Arrays.asList(str));

Set接口

Set接口是Collection的子接口，类似于集合，不允许有重复的元素。

Set接口的常用实现类有HashSet类、TreeSet类、LinkedHashSet类。

HashSet类

HashSet类用散列方法存储元素，具有最好的存取性能，但元素没有顺序。

//HashSet类的构造方法
HashSet():创建一个空的散列集合，该集合的默认初始容量是16，默认装填因子是0.75。（装填因子决定何时对散列表进行再散列）。
HashSet(Collection c):用指定的集合c的元素创建一个散列集合。
HashSet(int initialCapacity):创建一个散列集合，并指定集合的初始容量。
HashSet(int initialCapacity,float loadFactor):创建一个散列集合，并指定集合的初始容量和装填因子。

用Set对象实现集合运算

s1.addAll(s2):实现集合s1与s2的并运算。
s1.retainAll(s2):实现集合s1与s2的交运算。
s1.removeAll(s2):实现集合s1与s2的差运算。
s1.containAll(s2):如果s2是s1的子集，该方法返回true。

TreeSet类

TreeSet实现一种树集合，使用红-黑树为元素排序，添加到TreeSet中的元素必须是可比较的，即元素的类必须实现Comparable<T>接口，它的操作要比HashSet慢。

//TreeSet类的默认构造方法是创建一个空的树集合。
TreeSet(Collection c):用指定集合c中的元素创建一个新的树集合，集合中的元素按自然顺序排序。
TreeSet(Comparator c):创建一个空的树集合，元素的排序规则按给定的比较器c的规则排序。
TreeSet(SortedSet s):用SortedSet对象s中的元素创建一个树集合，排序规则与s的排序规则相同。

TreeSet类实现了SortedSet接口中下面的常用方法。

E first():返回有序集合中的第一个元素。
E last():返回有序集合中的最后一个元素。
SortedSet<E> subSet(E formElement,E toElement):返回有序集合中的一个子有序集合，他的元素从formElement开始到toElement结束。（前闭后开）。
SortedSet<E> headSet(E toElement):返回有序集合中小于指定元素toElement的一个子有序集合。
SortedSet<E> tailSet(E formElement):返回有序集合中大于等于formElement元素的有序集合。
SortedSet<? super E> comparator():返回与该有序集合相关的比较器，如果集合使用自然顺序则返回null。

Queue接口

Queue接口是Collection的子接口，前进先出的方式排列其元素，一般称为队列。

Deque接口对象实现双端队列，ArrayDeque和LinkedList的两个实现类。PriorityQueue实现的一种优先队列（根据元素的值排列）。

//失败时抛出异常
boolean add(E e):将指定的元素e插入到队列中。
E remove():返回队列头元素，同时将其删除。
E element():返回队列头元素，但不将其删除。
//失败时返回false或null
boolean offer(E e):将指定的元素e插入到队列中。
E poll():返回队列头元素，同时将其删除。
E peek():返回队列头元素，但不将其删除。

Deque接口

实现双端队列，支持从两端插入和删除元素，同时实现了Stack和Queue的功能。

//插入元素：（4）
addFirst(e):队首。
offerFirst(e):队首。
addLast(e):队尾。
offerLast(e):队尾。
//删除元素：（4）
removeFirst()、pollFirst()
//返回元素：（4）
getFirst()、peekFirst()
//删除第一次出现的元素 removeFirstQccurence()
//删除最后出现的元素 removeLastQccurence()

Deque的常用实现类包括ArrayDeque类和LinkedList类（同时实现了List接口和Queue接口），前者是可变数组的实现，后者是线性表的实现，LinkedList类比ArrayDeque类更灵活，实现了线性表的所有操作，其中可以存储null元素，但ArrayDeque对象不能存储null。

//LinkedList的构造方法
LinkedList():创建一个空的链表。
LinkedList(Collection c):用集合c中的元素创建一个链表。

集合转换

Queue<String> queue = new LinkList<>();
queue.add("hello");
List<String> myList = new ArrayList(queue);
Set<String> set = new HashSet(myList);

Map接口

Map是用来存储“键值”对，并要求关键字是唯一的，而值可以重复。其常用实现类有HashMap类，TreeMap类，Hashtable类,LinkedHashMap类。

基本操作

public V put(K key,V value):向映射对象中添加一个“键/值”对。
public V get(Object key):返回指定键的值。
public V remove(Object key):从映射中删除指定键的“键/值”对。
public boolean containsKey(Object key):返回映射中是否包含指定的键。
public boolean containsValue(Object value):返回映射中是否包含指定的值。
default V replace(K key,V value):若指定的“键/值”对存在于映射中，用指定的“键/值”对替换。
default void forEach(BiConsumer<? super K,? super V>):对映射中的每项执行一次动作，直到所有项处理完或发生异常。
public int size():返回映射中包含“键/值”对的个数。
public boolean isEmpty():返回映射是否为空。

批量操作

public void putAll(Map<? extends K,? extends V> map):将参数map中的所有“键/值”对添加到映射中。
public void clear():删除映射中所有“键/值”对。
public Set<K> keySet():返回由键组成的Set对象。
public Collection<V> values():返回由值组成的Collection对象。
public Set<Map.Entry<K,V>> entrySet():返回包含Map.Entry<K,V>的一个Set对象。

HashMap类

HashMap类以散列方法存放“键/值”对。

//构造方法
HashMap():创建一个空的映射对象，使用默认的装填因子0.75。
HashMap(int initialCapacity):用指定初始容量和默认装填因子创建一个映射对象。
HashMap(Map m):用指定的映射对象m创建一个新的映射对象。

TreeMap类

TreeMap类实现了SortedMap接口，保证Map中的“键/值”对按关键字升序排序。

//构造方法
TreeMap():创建根据键的自然顺序排序的空映射。
TreeMap(Comparator c):根据给定的比较器创建一个空映射。
TreeMap(Map m):用指定的映射m创建一个新的映射，根据键的自然顺序排序。

在键和值上迭代

//增强的for循环在键上迭代
for(String key:map.keySet()){
    System.out.println(key);
}
//在值上迭代
for(Integer value:map.values()){
    System.out.println(value);
}
//在“键/值”对上迭代
for(Map.Entry<String,Integer> entry:map.entrySet()){
    String k = entry.getKey();
    Integer v = entry.getValue();
    System.out.println(k+":"+v);
}
map.forEach((k,v)->{
    System.out.println(k+":"+v);
})

Collections类

Collections类是java.util包中定义的工具类。

排序

public static<T> void sort(List<T> list);
public static<T> void sort(List<T> list,Comparator<? super T> c);
//该方法使用优化的归并排序算法，因此排序是快速和稳定的，在排序时如果没有提供Comparator对象，则要求List中的对象必须实现Comparable接口。

List<String> names = Arrays.asList("peter","anna");
Collection.sort(name,(a,b)->b.compareTo(a));
names.forEach(System.out::println);

查找

//在已排序的List中查找指定的元素
//找到返回元素的下标，找不到返回-1
public static<T> int binarySearch(List<T> list,T key);
public static<T> int binarySearch(List<T> list,T key,Comparator c);

不能在原来的List上执行插入操作，否则会引发异常。

打乱元素次序

public static void shuffle(List<?> list):使用默认的随机数打乱List中元素的次序。
public static void shuffle(List<?> list,Random rnd):使用指定的Random对象，打乱List中元素的次序。

求极值

public static <T> max(Collection<? extends T> coll):返回集合中的最大值。
public static <T> max(Collection<? extends T coll,Comparator<? super T> comp):根据比较器comp返回集合中最大值。
public static <T> min(Collection<? extends T> coll):返回集合中的最小值。
public static <T> min(Collection<? extends T coll,Comparator<? super T> comp):根据比较器comp返回集合中最小值。

其他常用方法

public static void reverse(List<?> list):该方法用来反转List中元素的顺序。
public static void fill(List<? super T> list,T obj):用指定的值覆盖List中原来的每个值，该方法主要用于对List进行重新初始化。
public static void copy(List<? super T> dest,List<? extends T> src):将src的元素复制到dest中并覆盖其中的元素，dest中的元素个数不少于src。
public static void swap(List<?> list,int i,int j):交换List中指定位置的两个元素。
public static void rotate(
List<?> list,int distance):旋转列表，将i位置的元素移动到(i+distance)%list.size()的位置。
public static <T> boolean addAll(Collection<? super T> c,T...elements):该方法用于将指定的元素添加到集合c中，可以指定单个元素或数组。
public static int frequency(Collection<?> c,Object o):返回指定的元素o在集合c中出现的次数。
public static boolean disjoint(Collection<?> c1,Collection<?> c2):判断两个集合是否不相交，如果两个集合不包含相同的元素，则该方法返回true。