Java基础（集合框架——Collection、List、Set、泛型）

时间：2022-09-23 17:56:04


为什么出现集合类？

面向对象语言对事物的体现都是以对象的形式，所以为了方便对多 个对象的操作，就对对象进行存储，集合就是存储对象常用的一 种方式。

数组和集合类同是容器，有何不同？

数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。 数组中可以存储基本数据类型，集合只能存储对象。

集合类的特点

集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象

集合体系

Java基础（集合框架——Collection、List、Set、泛型）


Collection

Collection是集合框架中常用的接口，旗下有两个子接口：List（列表）和Set（集）

List：可存放重复元素，元素取出和存入的顺序是一致的

Set：不可以存放重复元素，元素的取出和存入的顺序不一定一致

一、Collection 接口中常用的方法

        1、添加

1、all(E e)          //E暂时可以看作是Object   可以添加任意类型

2、addAll(Collection collection)           将指定集合中的元素添加到该集合中

        2、删除

1、remove(E   e)        //删除指定元素

2、remove(Collection   collection)   //去交集   ，也就是该集合中会保留指定集合中没有的元素，如果指定集合中的元素与该集合中的元素完全相同，那么该集合将为NULL

3、clear()                 //删除集合中的所有元素

        3、判断

1、contains(E    e)      //判断指定元素是否存在

2、isEmpty();            //判断集合是否为NUll     其实就是在判断size()是否为0

        4、获取

1、size()            //获取集合的长度

2、iterator()      迭代器，用于获取集合中的每个元素  和for循环原理相同

二、迭代器

1、什么是迭代器？

        迭代器其实就是集合中取出元素的方式  如：DNF中的娃娃机

2、对于迭代器取出元素的动作：

       当不足以用一个函数来描述，需要多个功能来体现时，所以就将取出这个动作封装成了一个对象，用对象来进行描述，所以就把取出方式定义在集合内部，这样取出方式就可以直接访问集合中的元素，那么取出方式就被定义成了内部类。

       因为每个容器的数据结构不同，所以取出的动作和细节也不一样，但是都有共性的内容：判断和取出，那么可以将这些共性进行抽取，那么该类就就都符合一个规则，该规则就是Iterator接口，而想要获取集合中取出的对象，可以通过一个对外提供的方法iterator()来获取

3、迭代常用方法

        1、next()                       取出一个元素

        2、hasNext()                判断是否还有元素   返回一个boolean类型的结果

        3、remove()                 删除当前元素

       注意：想要将集合中的元素全部取出，必须使用循环每取一次(next())，判断一次(hasNext())  知道hasNext为false，结束循环

4、迭代用法:

          <span style="font-size:14px;">      ArrayList al1 = new ArrayList();
al1.add("java01");
al1.add("java02");
al1.add("java03");
al1.add("java04");
//第一种用法
Iterator it = all.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
//第二种用法
for(Iterator it = all.iterator();it.hasNext();){
System.out.prinln(it.next());
}</span>
注意：iterator是Collection接口中的方法，所以每一个子类集合对象多具备迭代器

5、使用迭代注意事项

1、  迭代器在Collection接口中是通用的，它替代了Vector类中中的枚举

2、迭代器的next方法是自动向下取元素，但是一个循环中不可以出现多个next，要避免出现NoSuchElementException异常

3、迭代器的next方法返回值类型是Object，所以应注意转换

问题：为什么迭代器的next方法的返回值类型是Object呢？

        原因：因为集合中可以存储的类型只能是对象（String、int都是对象），所以返回值一定是对象的祖先Object



List

Collection
    |--List:元素是有序的，元素可以重复。因为该集合体系有索引。
        |--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。   底层使用的都是可变数组，每次加长50%
        |--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。
        |--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。  底层使用的都是可变数组，每次加长100%

虽然Vector已经被ArrayList替代了，但是它里面有一些特殊的方法是ArrayList没有的，就是枚举，其实枚举和迭代的原理是一样的，但是后面学习IO时可能会用到枚举，所以还是说一下Vector把

Vector中特有的方法：

1、elements()       //相当于iterator()

2、hasMoreElements()       相当于hasNext(0

3、nextElement()     //相当于next()

<span style="font-size:14px;">import java.util.*;
class VectorDemo 
{
public static void main(String[] args) 
{
Vector v = new Vector();

v.add("java01");
v.add("java02");
v.add("java03");
v.add("java04");

Enumeration en = v.elements();    //elements返回值类型为Enumeration类

while(en.hasMoreElements())
{
System.out.println(en.nextElement());
}
}
}</span>

一、List中特有的方法

只要是可以操作角标的方法都是List集合中特有的方法，因为List集合有索引

1、增

       add(int  index)

       add(int  index, Collection  collection)

2、删

       remove(int index)

3、改

       set(int  index)

4、查

       get(index)

       subList(头,  尾)

       indexOf(int  index)

       lastIndexOf(int index)

       listIterator()                        //注：有点特殊

二、listIterator方法

1、用法：listIterator方法的用法和iterator方法的用法相同，只不过listIterator的返回值类型为ListIterator，是 Iterator的一个子接口，而 iterator方法返回值类型为Iterator接口

2、listIterator和iterator的区别：

            因为iterator方法返回的结果是Iterator ，而Iterator接口中仅仅只有对元素的删除操作，所以当使用Iterator是不可以对元素进行出删除操作之外的操作的，有局限性，而ListIterator类中定义了很多对元素操作的方法，所以当需要多元素进行删除以外的操作时，建议使用Iterator的子接口ListIterator中的listIterator方法获取

3、ListIterator特有方法

        1、get()

        2、add()

        3、hasPrevious()          判断前面是否还有元素

        4、previous()                 向前获取元素

        5、set(Object obj);

LinkedList

一、LinkedList特有方法

1、增       

        addFirst();

        addLast();

2、删          注：使用该方法时，该方法不仅会删除元素，还会返回要删除的元素  如果集合为空  则会出现NoSuchElementException

        removeFrist()

        removeLast()

3、获取      注：使用该方法时，该方法只会获取元素，不会删除元素   如果集合为空  则会出现NoSuchElementException

        getFirst();

        getLst()

在JDK1.6以后，出现了替代方法。

1、增

        offFirst();

        offLast();

2、获取

        //获取元素，但是不删除。如果集合中没有元素，会返回null。

        peekFirst();

        peekLast();

3、删

        //获取元素，并删除元素。如果集合中没有元素，会返回null。

        pollFirst();

        pollLast();

4、练习1：
 
<span style="font-size:14px;">/*
需求：模拟一个堆栈和队列数据结构
堆栈：先进后出   如同一个杯子
队列：先进先出   如同一个管子
*/
class DemoTest 
{

private LinkedList link;
//初始化一个LinkedList集合
DemoTest(){
this.link = new LinkedList();
}
//自己内部完成添加
public void myAdd(Object obj){
link.addFrist(obj);
}
//堆栈
public void getDuiZhan(){
while(!link.isEmpty()){
System.out.println(link.removeFirst());
}
}
//队列
public void getDuiLie(){
while(!link.isEmpty()){
System.out.println(link.removeLast());
}
}
}

public class Test {
public static void main(String [] agrs){
DemoTest de = new DemoTest();
de.myAdd("lisi01");
de.myAdd("lisi02");
de.myAdd("lisi03");
de.myAdd("lisi04");
de.myAdd("lisi05");
//输出队列
de.getDuiLie();
//输出堆栈
de.getDuiZhan();
}
}
</span>
5、练习2：去除Arraylist中的重复元素 
<span style="font-size:14px;">/*需求：去除List集合中的重复元素*/class ListUtil{//消除重复值后输出public static void get(List li){for(Iterator it = contains(li).iterator();it.hasNext();){System.out.println(it.next());}}//把重复元素清除后添加到一个新的List集合中private static List contains(List li){List list = new ArrayList();for(Iterator it = li.iterator();it.hasNext();){Object obj = it.next();if(!list.contains(obj))list.add(obj);}return list;}}public class DemoTest {public static void main(String [] args){LinkedList list = new LinkedList();list.add("li001");list.add("li001");list.add("li003");list.add("li002");list.add("li005");list.add("li002");ListUtil.get(list);}}</span>

6、练习3、去除集合中的重复对象

<span style="font-size:14px;">import java.util.*;
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name = name;
this.age = age;
}
/*这里必须复写equals方法*/
public boolean equals(Object obj)
{
//用于判断equals方法是否执行
System.out.println("？？？？？？？？？？");
if(!(obj instanceof Person))
return false;
Person p = (Person)obj;
                //这里只要是名字和年龄相同就认为是同一个人
return this.name.equals(p.name) && this.age == p.age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
class DemoTest3 
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args) 
{
ArrayList set = new ArrayList();
//Set set = new HashSet();
set.add(new Person("lisi01",30));//al.add(Object obj);//Object obj = new Person("lisi01",30);
set.add(new Person("lisi02",32));
set.add(new Person("lisi02",32));
set.add(new Person("lisi04",35));
set.add(new Person("lisi03",33));
set.add(new Person("lisi04",35));
/*发现在Person类中复写了equals方法之后，并没有去除重复对象，这是为什么呢？
我们都知道对象比较的是equals方法，为什么我们复写了equals方法还是不行呢？
因为如果我们在equals方法中打印输出一条语句的话，我们就会发现该语句根本就没有执行？
这又是为什么呢？这就说明计算机底层并没有帮我们调用我们复写的equals方法
而不执行equals方法肯定是去除不掉重复对象的，所以这时候我们最大的问题应该是调用equals
方法，只要执行了equal方法那么肯定能去除重复对象，所以，这时候我们contain方法来解决
因为contains方法底层用的都是equals方法，我们调用了contains不就等于调用了equals方法么？
所以，我们可以先用contain判断一下，把不存在的值放入到一个新容器中，所以就有了singleElement方法*/
set = singleElement(set);
for(Iterator it = set.iterator();it.hasNext();){
Person p = (Person) it.next();
System.out.println(p.getName()+"...."+p.getAge());
}
}


public static ArrayList singleElement(ArrayList al)
{
//定义一个临时容器。
ArrayList newAl = new ArrayList();

Iterator it = al.iterator();

while(it.hasNext())
{
Object obj = it.next();

if(!newAl.contains(obj))
newAl.add(obj);

}

return newAl;
}
}</span>

Set

Set:无序，不可以重复元素。
    |--HashSet：数据结构是哈希表。线程是非同步的。
                保证元素唯一性的原理：判断元素的hashCode值是否相同。
                如果相同，还会继续判断元素的equals方法，是否为true。

    |--TreeSet：可以对Set集合中的元素进行排序。
                底层数据结构是二叉树。
                保证元素唯一性的依据：
                compareTo方法return 0.

                TreeSet排序的第一种方式：让元素自身具备比较性。
                元素需要实现Comparable接口，覆盖compareTo方法。
                也种方式也成为元素的自然顺序，或者叫做默认顺序。

                TreeSet的第二种排序方式。
                当元素自身不具备比较性时，或者具备的比较性不是所需要的。
                这时就需要让集合自身具备比较性。
                在集合初始化时，就有了比较方式。

注：Set接口中的方法和Collection接口中的方法是一样的，所以在使用Set子类时获取元素时，只能通过迭代的方式

HashSet

注：HashSet对于判断元素是否存在，以及删除等操作，依赖的方法都是元素的hashCode方法和equals方法

练习：去除HashSet中的重复对象

/*需求：消除HashSet中的重复对象*/
import java.util.*;
class Person
{
private String name;
private int age;
public Person(String name,int age){
this.name = name;
this.age = age;
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
//重写Object类中的hashCode方法
public int hashCode(){
//这样写能尽可能的保证哈希值唯一
return this.name.hashCode()+age*24;
}
//重写Object类中的equals方法
public boolean equals(Object obj){
if(!(obj instanceof Person))
throw new RuntimeException();
Person p = (Person) obj;
return this.name.equals(p.name);
}
}
public class HashSetDemo 
{
public static void main(String[] args) 
{
Set set = new HashSet();
set.add(new Person("li01",21));
set.add(new Person("li01",21));
set.add(new Person("li02",21));
set.add(new Person("li03",21));
set.add(new Person("li05",21));
set.add(new Person("li02",21));
for(Iterator it = set.iterator(); it.hasNext();){
Person p = (Person) it.next();
System.out.println(p.getName()+":"+p.getAge());
}
}
}

TreeSet

特点：

可对Set集合中的元素进行排序，是因为：TreeSet类实现了Comparable接口，该接口强制让增加到集合中的对象进行了比较，需要复写compareTo方法，才能让对象按指定需求（如人的年龄大小比较等）进行排序，并加入集合。

        java中的很多类都具备比较性，其实就是实现了Comparable接口。

注意：排序时，当主要条件相同时，按次要条件排序。 

二叉树示例图：

二叉树原理：通过compareTo方法的返回值，是正整数、负整数或零，则两个对象较大、较小或相同。根据返回值来存放，正数则放在右边，负数这放在左边，0则证明相等，不存入

Java基础（集合框架——Collection、List、Set、泛型）

2、Tree排序的两种方式   当自然排序和比较器同时存在时，以比较器为主

        1）第一种排序方式：自然排序

        让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。这种方式也被称为元素的自然顺序，或者叫做默认顺序。

示例：

/*
TreeSet自然排序
*/

import java.util.*;
class Person implements Comparable
{
private String name;
private int age;
public Person(String name,int age){
this.name = name;
this.age = age;
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
//重写comepareTo()方法让对象具备比较性
public int compareTo(Object obj){
if(!(obj instanceof Person))
throw new RuntimeException();
Person p = (Person) obj;
//让对象先按姓名排序后如果姓名相同再按年龄排序
int num = this.name.compareTo(p.name);
if(num==0)
return this.age - p.age;
//return new Integer(this.age).compareTo(new Integer(p.age))
return num;
}
}
public class TreeSetDemo 
{
public static void main(String[] args) 
{
Set set1 = new TreeSet();
set1.add(new Person("li01dfds————",23));
set1.add(new Person("li01dsfs————",21));
set1.add(new Person("li02assa————",24));
set1.add(new Person("li03fdds————",20));
set1.add(new Person("li05asf————",19));
set1.add(new Person("li02sdfs————",21));
show(set1);

}
public static void show(Set set){
for(Iterator it = set.iterator(); it.hasNext();){
Person p = (Person) it.next();
System.out.println(p.getName()+":"+p.getAge());
}
}
}

        2）第二种方式：比较器

        当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。

        在集合初始化时，就有了比较方式。定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

        比较器构造方式：定义一个类，实现Comparator接口，覆盖compare方法。创建一个带有Comparator对象的构造函数

        当两种排序都存在时，以比较器为主。

示例：

/*比较器*/
public class TreeSetDemo 
{
public static void main(String[] args) 
{
Set set1 = new TreeSet(new Com());
set1.add(new Person("li04————",23));
set1.add(new Person("li02————",21));
set1.add(new Person("li00————",24));
set1.add(new Person("li03————",20));
set1.add(new Person("li05————",19));
set1.add(new Person("li01————",21));
show(set1);

}
public static void show(Set set){
for(Iterator it = set.iterator(); it.hasNext();){
Person p = (Person) it.next();
System.out.println(p.getName()+":"+p.getAge());
}
}
}
//比较器排序
class Com implements Comparator
{
public int compare(Object obj1,Object obj2){
Person p =(Person)obj1;
Person p2 =(Person)obj2;
int num = p.getName().compareTo(p2.getName());
if (num==0)
return new Integer(p.getAge()).compareTo(new Integer(p2.getAge()));
return num;
}
}

泛型

一、泛型概述

泛型是JDK1.5版本后出现的新特性，用来解决安全问题，是一个安全机制

二、作用

1、把运行时期会遇到的类型转换错误（ClassCastException）转移到编译时期，方便程序员解决问题

2、避免了强制转换的麻烦

三、泛型定义

1、泛型定义在类上（泛型类）

    特点：泛型类定义在类上时，泛型在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体泛型后，所有操作的类型就已经固定了

/*泛型定义在类上*/
class FanXing<T>
{
private T t;
public void setObject(T t){
this.t = t;
}
public T getObject(){
return t;
}
public void show(T t){
System.out.println(t);
}
}
class Student
{
}
class Work
{
}
class  FanXingDemo
{
public static void main(String[] args) 
{
/*
会出错的情况：
1、
FanXing<Student> f = new FanXing<Student>();
f.setObject(new Student());
//这样写会报错  因为前面返回值类型已经固定为Student
Work w = f.getObject();

2、
FanXing<Work> f = new FanXing<Work>();
//这样写会报错  因为类型已经固定为Work
f.setObject(new Student());
Work w = f.getObject();

3、
FanXing<String> f = new FunXing<String>();
f.show("mmmmmmmm");
//这样写会报错，因为类型已经固定位String类型
f.show(4);
*/


/* 
不会出错的情况
1、
FanXing<Student> f = new FanXing<Student>();
f.setObject(new Student());
Student s = f.getObject();


2、
FanXing<String> f = new FunXing<String>();
f.show("mmmmmmmm");
f.show("kkkkkkkk");
*/
}
}
2、泛型定义在方法上 

class FanXing1<T>
{
public <T> void show(T t){
System.out.println(t);
}
}
class  FanXingDemo
{
public static void main(String[] args) 
{
/*泛型定于在方法上，就没有了局限性
虽然说类上也定义了泛型，但是方法上使用的并不是类上泛型的类型，所以不会报错
*/

FanXing1<String> f1 = new FanXing1<String>();
f1.show("aaaaaaaaaaaaa");
f1.show(5);
f1.show(new Integer(111111));
f1.show('b');
}
}
3、泛型定义在接口上 

/*
泛型定义在接口上
*/
interface Demo<T>
{
void show(T t);
}
class DemoTest<T> implements Demo<T>  //当不确定使用什么类型时，可以不定义类型，让子类去定义
{
public void show(T t){   //泛型类型必须和接口的泛型一致，不然不会被重写，DemoTest类也会变成抽象类
System.out.println(t);
}
}

public class  FanXingInterface
{
public static void main(String[] args) 
{
/*
会出错的情况：
1、
//泛型类型不一致
DemoTest<Integer> d = new DemoTest<Integer>();
d.show("aaaaaaaaa");

2、
//泛型类型不一致
DemoTest<String> d = new DemoTest<String>();
d.show(3);
*/

//不会出错
DemoTest<Integer> d = new DemoTest<Integer>();
d.show(3);



}
}
泛型高级应用：

1、？通配符   相当于Object

2、？ extends E    可以接收E类型或E类型的子类型

3、？ super E     可以接收E类型或E的父类型

import java.util.*;
/*
? 通配符。也可以理解为占位符。
泛型的限定；
？ extends E: 可以接收E类型或者E的子类型。上限。
？ super E: 可以接收E类型或者E的父类型。下限

*/

class Person
{
private String name;
Person(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
}

class Student extends Person
{
Student(String name)
{
super(name);
}

}

class  GenericDemo6
{
public static void main(String[] args) 
{
ArrayList<Person> al = new ArrayList<Person>();
al.add(new Person("abc1"));
al.add(new Person("abc2"));
al.add(new Person("abc3"));
printColl(al);

ArrayList<Student> al1 = new ArrayList<Student>();
al1.add(new Student("abc--1"));
al1.add(new Student("abc--2"));
al1.add(new Student("abc--3"));
printColl(al1);  //ArrayList<? extends Person> al = new ArrayList<Student>();error

}
public static void printColl(Collection<? extends Person> al)  //这样写代表printColl函数可以接收Collection集合，而collection集合中的元素必须是Person类型或Person的子类型
{
Iterator<? extends Person> it = al.iterator();


while(it.hasNext())
{
System.out.println(it.next().getName());
}
}
/*
public static void printColl(ArrayList<?> al)   //代表printColl函数可以接收的类型是ArrayList集合，而集合中的元素可以是任意类型
{
Iterator<?> it = al.iterator();


while(it.hasNext())
{
System.out.println(it.next().toString());
}
}
*/
}

标签：

相关文章