Day2-java泛型与集合

 
  1. 对象顺序，Comparable接口及其使用
  2. Queue接口和实现类的使用　　了解
  3. Map接口及实现类的使用
  4. Collections类的实用方法操作List对象
  5. StreamAPI的使用　　了解

泛型类型 

取出和输入不用强制类型转换

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

Node<T> node = new Node<T>();
或者
Node<T> node = new Node<>();

泛型类型的使用与方法调用类似，方法调用需向方法传递参数，使用泛型需传递一个类型参数，即用某个具体的类型替换T。

常用的类型参数名：

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

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

 

public interface Entry<K,V>{
    public K getKey();
    public V getValue();
}
或
Pair<Integer,String> p1 = new Pair<>(20,"twenty");
Pair<String,String> p2 = new Pair<>("China","Beijing");

 

泛型方法

泛型方法是带类型参数的方法，类的成员方法和构造方法都可以定义为泛型方法。

泛型方法类型参数的作用域仅限于声明的方法和构造方法内。

可为静态也可为非静态。

public static <T> void swap(T[] array,int i,int j){
}

通配符（？）的使用

public static void printList(List<?> list){
}

表示该方法可接受的元素是任何类型的List对象

有界类型参数

限制传递类型参数的类型种类。

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

例：声明上（下）界类型参数，使用？，后跟extends（super）关键字，然后是上（下）界类型

List<? extends Number> numberList

 

集合框架

集合是集中存放一组对象的一个对象。相当于一个容器，提供保存，获取和操作其他元素的方法。

java集合框架由Collection和Map构成，Collection对象用于存放一组对象，Map对象用于存放一组“关键字/值”的对象。

 Collection接口的集合操作常用方法可分为基本操作，批量操作，数组操作，流操作。

基本操作：有添加元素，删除指定元素，返回集合中元素的个数，返回集合的迭代器对象。

  • add（E e）：向集合中添加元素e；
  • remove（Object o）：从集合中删除指定的元素o；
  • contains（Object o）：返回集合中是否包含指定的元素o；
  • size（）：返回集合中包含的元素个数；
  • iterator（）：返回包含所有元素的迭代器对象

批量操作：

  • addAll（Collection<? extends E> c）:将集合c中的所有元素添加到当前集合中；
  • removeAll（Collection<?>c）:从当前集合中删除c中的所有元素；
  • containsAll（Collection<?>c）:返回当前集合是否包含c中的所有元素；
  • retainAll（Collection<?>c）:在当前集合中只保留指定集合c中的元素，其他元素删除；
  • clear（）：将集合清空

数组操作：将集合元素转换成数组元素

  • Object[ ] toArray（）：返回包含集合中所有元素的对象数组

List接口及实现类

List接口是Collection的子接口，实现一种线性表的数据结构，存放在List中的元素都从下标0开始，可包含重复元素。

List的操作：既继承Collection的方法，还实现可定位访问、查找、迭代、返回子线性表

  • get（int index）：返回指定下标处的元素；
  • set（int index，E element）：修改指定下标处的元素；
  • add（int index，E element）：将指定元素插入到指定下标处；
  • remove（int index）：删除指定下标处的元素；
  • iterator（）：获得表的遍历器；
  • indexOf（Object o）：查找指定对象第一次出现的位置；
  • lastIndexOf（Object o）：查找指定对象最后一次出现的位置；
  • List<E>subList(int from,int to)：返回从from到to元素的一个子线性表；

List虽然继承Collection，但有的操作不同，如：remove（）：从线性表中删除指定首次出现的元素

　　　　　　　　　　　　　　　　　　　　　add（）和addAll（）：将元素插入到线性表的末尾

ArrayList类

通过数组实现的集合对象，元素可以动态地增加和删除，快速访问、频繁的增删。

ArrayList的构造方法：

  • ArrayList（）：创建一个空的数组线性表对象，默认初始容量为10，线性表大小自动增大
  • ArrayList（Collection c）：用集合c中的对象创建一个线性表对象
  • ArrayList（int initialCapacity）：创建一个空的线性表对象，指定初始容量

遍历集合元素

方法：1简单的for循环、2增强的for循环、3用Iterator迭代器对象

1

for(int i=0;i<bigCities.size();i++){
        System.out.print(bigCities.get(i)+" ");
}

2

for (String city : bigCities){
    System.out.println(city);
}

含义：将集合bigCities中的每个对象存储到city变量中，然后打印输出。（只能访问，不能修改或删除）

若只是简单的输出每个元素，可以调用集合对象的forEach（）方法：

bigCities.forEach(System.out::println);

3

迭代器是一个可以遍历集合中每个元素的对象。调用集合对象的iterator（）方法可以得到Iterator对象，再调用Iterator对象的方法就可以遍历集合中的每个元素。Iterator接口定义如下3个方法：

  1. hasNext（）：返回迭代器中是否还有对象
  2. next（）：返回迭代器中下一个对象
  3. remove（）：删除迭代器中的当前对象

访问myList中的每一个元素：

Iterator iterator = myList.iterator();    //得到迭代器
wile(iterator.hasNext()){
    System.out.println(iterator.next());
}

Iterator开始指向第一个元素的前面，如果指针后面还有元素，hasNext（）方法返回true。调用next（）方法指针将移到下一个元素并返回该元素。

双向迭代器

可以从前后两个方向遍历线性表中的元素，可以修改元素、获得元素当前的位置，是Iterator的子接口，常用方法有：

  • hasNext（）：返回是否还有下一个元素
  • next（）：返回下一个元素
  • hasPrevious（）：返回是否还有前一个元素
  • previous（）：返回前一个元素
  • nextIndex（）：返回下一个元素的索引
  • previousIndex（）：返回前一个元素的索引
  • remove（）：删除当前元素
  • set（E o）：修改当前元素
  • add（E o）：在当前位置插入一个元素

不能同时使用两个迭代器修改一个线性表中的元素，否则将抛出异常。

//将迭代器指针从前往后移
while(iterator.hasNext()){
    iterator.next();
}
//从后往前
while(iterator.hasPrevious()){
    System.out.println(iterator.previous());
}

数组转化为List对象

 方法的定义如下：

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

asLIst（）方法与Collection接口的toArray（）方法相反

String[] str = {"one","two","three","four"};
List<String> list = Arrays.asList(str);    //将数组转换为列表            
System.out.println(list);
或
List<String> list = new ArrayList("one","two","three","four");

Arrays.asList（）方法返回的List对象是不可变的，若要对List对象操作，则将其作为一个参数传递给另一个List的构造方法

Vector类和Stack类分别实现向量和对象栈。栈：后进先出

Set接口及实现类

Set接口对象类似于数学上的集合概念，不允许有重复的元素。

Set接口没有定义新方法，从Collection中继承。

常用实现类：HashSet类，TreeSet类（存放的数按从小到大排序）

HashSet类

用散列方法存储元素，具有最好的存储性能，构造方法有：

  • HashSet（）：创建一个空的散列集合，默认容量16，以0.75自动填充
  • HashSet（Collection c）：用指定集合c的元素创建一个散列集合
  • HashSet（int initialCapacity）：创建一个散列集合，并指定集合的初始容量
  • HashSet（int initialCapacity，float loadFactor）：创建集合，指定容量和装填因子

用Set对象实现集合运算

  • s1.addAll（s2）：实现并运算
  • s1.retainAll（s2）：交运算
  • s1.removeAll（s2）：差运算
  • s1.containAll（s2）：如果s2是s1的子集，返回true

TreeSet类

实现树集合，以红-黑树为元素排序，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 fromElement,E toElement):返回有序集合中的一个子有序集合，它的元素从fromElement开始到toElement结束（不包括最后元素）
  • SortedSet<E> headSet(E toElement)：返回有序集合小于指定元素toElement的一个子有序集合
  • SortedSet<E> tailSet(E fromElement)：返回有序集合大于等于指定元素fromElement的一个子有序集合

对象顺序

自然顺序是指集合对象实现了Comparable接口的compareTo（）方法

字符串的默认比较规则是按字母顺序比较

Comparable接口和Comparator接口

比较两个String对象的大小，用String类的ComparaTo（）方法

类的对象比较大小，需要实现Comparable<T>接口的comparaTo（）方法，该方法实现当前对象与参数对象的比较，返回一个整数值，当调用对象小于，等于，大于参数对象时，返回负整数，0，正整数。按这种方法比较出的对象顺序称为自然顺序

Comparable<T>接口的定义：

package java.lang;
public interface Comparable<T>{
    int comparaTo(T other);
}

 

posted @ 2023-05-27 14:08  gm学习日记  阅读(46)  评论(0)    收藏  举报