Java进阶第七章——数据结构：Collection

发布时间：2024年01月15日

数据结构：Collection

本章所涉及到的数据结构知识可在数据结构学习记录中学习：
咖啡ice的数据结构学习记录

1.Collection常用方法

没有使用“泛型”之前，Collection中可以存储Object中的所有子类型。
集合不能直接存储基本数据类型，也不能存储java对象。只能存储java对象的内存地址。
Collection中常用方法：

往集合里加元素：boolean add(Object e)

获取集合中元素个数：int size()

清空集合：void clear()

判断集合是否包含元素：boolean contains(Object o)

删除集合中某个元素：boolean remove(Object o)

判断集合是否为空：boolean isEmpty()

把集合转换成数组：Object[] toArray()

package collection;

import java.util.ArrayList;
import java.util.Collection;

public class CollectionTest {
    public static void main(String[] args) {
        //创建一个集合对象
        //Collection c = new Collection();  接口是抽象的，无法实例化
        Collection c = new ArrayList<>();//用一个父类型指向子类型。
        c.add(1200);//自动装箱，实际上放进去了一个对象的内存地址Integer x = new Integer(1200);
        c.add(new Object());
        System.out.println("集合中元素个数："+ c.size());  //集合中元素个数：2
        //清空集合
        c.clear();
        System.out.println("集合中元素个数："+ c.size());  //集合中元素个数：0

        c.add("ice");
        c.add("coffee");
        c.add("is");
        c.add("perfect");

        boolean flag = c.contains("coffee");
        System.out.println(flag); //true
        boolean flag2 = c.contains("coffee2");
        System.out.println(flag2); //false

        System.out.println("集合中元素个数："+ c.size());  //集合中元素个数：4
        c.remove("is");
        System.out.println("集合中元素个数："+ c.size());  //集合中元素个数：3

        System.out.println(c.isEmpty());  //false
        c.clear();
        System.out.println(c.isEmpty());  //true

        c.add("abc");
        c.add("def");
        c.add(100);
        c.add("ice-coffee");
        Object[] objs = c.toArray();
        for (int i = 0; i < objs.length; i++) {
            System.out.printf(objs[i] + " ");  //abc def 100 ice-coffee
        }

    }
}

所有Collection通用的一种方法：迭代方式(也就是遍历)。
在Map集合中不能用迭代器，而在Collection以及子类中使用。
迭代器定义的变量类似于指针，且不是指向第一个元素。，可以使用两个方法来迭代对象Iterator中方法：

? boolean hasNext() 如果仍有元素可以迭代(遍历)，则返回true。如果false表示没有更多元素可以迭代。

? Object next() 返回迭代的下一个元素。

注：也就是说迭代器对象指向要输出位置的前一个位置。

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionTest01 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        //存储时的类型和取出的类型一样
        c.add("ice");
        c.add("coffee");
        c.add(100);

        Iterator it = c.iterator();
        while(it.hasNext()){ //下一个元素存在，返回true
            System.out.printf(it.next() + "  ");  //ice  coffee  100
        }
    }
}

HashSet集合：无序不可重复

public class CollectionTest01 {
    public static void main(String[] args) {
        Collection c = new HashSet();
        //存进去和取出来顺序不一样
        c.add(100);+
        c.add(200);
        c.add(300);
        c.add(100);
        c.add(40);

        Iterator it = c.iterator();
        while(it.hasNext()){
            System.out.printf(it.next() + "  ");  //100  200  40  300 
        }
    }
}

contains()方法：

boolean contains(Object o)：判断集合中是否包含某个对象o，如果包含返回true，如果不包含返回false。

注：在底层中，contains()方法调用equals()方法，所以放在集合里边的对象需要重写equals()方法。

public class CollectionTest01 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add(new String("abc"));
        c.add(new String("def"));
        
        String x = new String("abc"); //由于String对象在new时会放到字符串常量池，创建相同的字段时会指向同一个位置。
        System.out.println(c.contains(x));  //true
        
        User u1 = new User("coffee");
        User u2 = new User("coffee");
        c.add(u1);  
        System.out.println(c.contains(u2));//这里没有重写，这个结果比较的是内存地址，结果是：false
    }
}
class User{
    private String name;
    public User(){

    }
    public User(String name){
        this.name = name;
    }
}

contains方法在底层会调用equals方法进行比较，所以这里对象重写了equals方法则会是true

public class CollectionTest {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        User u1 = new User("coffee");
        User u2 = new User("coffee");
        c.add(u1);
        System.out.println(c.contains(u2)); //true
    }
}
class User{
    private String name;
    public User(){  }
    public User(String name){ this.name = name; }
    //重写equals方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return Objects.equals(name, user.name);
    }
}

remove()方法：

boolean remove(Object o)：删除集合中包含某个对象o，如果包含返回true，如果不包含返回false。

注：在底层中，remove()方法调用equals()方法，所以放在集合里边的对象需要重写equals()方法。

public class CollectionTest01 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        String s1 = new String("hello");
        String s2 = new String("hello");
        c.add(s1);
        c.remove(s2);
        System.out.println(c.size());  //0
    }
}

综上所属，remove和contains两个方法在底层都需要调用equals方法，所以放在集合里边的对象需要重写equals()方法。

2.List常用方法

List集合特点：每个元素有下标(下标从0开始)，可以有重复元素。相当于数据结构中的线性表(数组)。
List作为Collection的子接口，list接口有自己常用的特色方法：

在指定位置插入指定元素：void add(int index,E element)

返回指定下标元素：E get(int index)

返回元素第一次出现索引：int indexOf(Object o)

返回元素最后一次出现索引：int lastIndexOf(Object o)

移除指定下标元素：E remove(int index)

用指定元素替换指定位置元素：E set(int index,E element)

package list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListTest{
    public static void main(String[] args) {
        //创建list类型集合
        List mylist = new ArrayList();
        //add()默认在数组末尾添加元素
        mylist.add("ice");
        mylist.add("coffee");
        mylist.add("is");
        mylist.add("nice");

        Iterator it = mylist.iterator();
        while(it.hasNext()){
            Object elt = it.next();
            System.out.printf(elt + " ");  //ice coffee is nice
        }

        System.out.println();  //分割线

        //add(index,element)在指定位置插入添加指定元素
        //这个方法使用效率低，使用情况较少
        mylist.add(1,"milk");
        Iterator it2 = mylist.iterator();
        while(it2.hasNext()){
            Object elt = it2.next();
            System.out.printf(elt + " ");  //ice milk coffee is nice
        }
        System.out.println();//分割线

        //根据下标获取元素get()方法
        System.out.println(mylist.get(0));  //ice


        //由于List有下标，List有独特的遍历方式for循环
        for (int i = 0; i < mylist.size(); i++) {
            System.out.printf(mylist.get(i) + " ");  //ice milk coffee is nice
        }

        System.out.println();//分割线
        //获取指定对象第一次出现处索引
        System.out.println(mylist.indexOf("is")); //3

        mylist.add(3,"coffee");
        //获取指定对象最后一次出现索引
        System.out.println(mylist.lastIndexOf("coffee")); //3

        //删除指定下标位置的元素
        mylist.remove(2);
        mylist.remove(1);
        for (int i = 0; i < mylist.size(); i++) {
            System.out.printf(mylist.get(i) + " ");  //ice coffee is nice
        }

        System.out.println();//分割线
        //修改指定位置元素
        mylist.set(3,"good");
        for (int i = 0; i < mylist.size(); i++) {
            System.out.printf(mylist.get(i) + " ");  //ice coffee is good
        }

    }
}

注：计算机英语常用增删改查几个单词

增：add、save、new

删：delete、drop

改：update、set、modify

查：find、get、query、select

3.List实现类——ArrayList

ArrayList特性：

①ArrayList集合初始化容量是10。

②ArrayList集合底层是Object类型的数组Object[]。

③构造方法：new ArrayList(); 或者 List list2 = new ArrayList(20);

④一般给定一个预估价初始化容量，减少数组扩容次数。每次扩容会扩1.5倍。

⑤数组检索效率高，使用频率最多。

⑥随机增删元素效率比较低。但是在末尾增加效率高不受影响。

⑦ArrayList是非线程安全的

package list;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;

public class ArrayListTest {
    public static void main(String[] args) {
        //默认初始化容量10
        List list1 = new ArrayList();
        //size()方法是获取当前集合中元素个数，而不是获取集合容量。
        System.out.println(list1.size()); //0

        //指定初始化容量
        List list2 = new ArrayList(20);

        //通过构造方法将HashSet集合转换成List集合
        Collection c = new HashSet();
        c.add("ice");
        c.add("coffee");
        List list3 = new ArrayList(c);
        for (int i = 0; i < list3.size(); i++) {
            System.out.printf(list3.get(i) + " ");  //coffee ice 
        }
    }
}

将非线程安全的ArrayList变成线程安全方法：Collections.synchronizedList

public class ArrayListTest {
    public static void main(String[] args) {
        List mylist = new ArrayList();
        Collections.synchronizedList(mylist);
        
        mylist.add("111");
    }
}

4.List实现类——LinkedList

LinkedList底层为双向链表数据结构。LinkedList集合底层也是有下标的，不过底层是双向链表，所以查找效率较低。
与ArrayList对比：

LinkedList在检索(查找)效率较低，在增删方面效率较高。

ArrayList在检索(查找)效率较高，在增删方面效率较低。不过只在末尾添加元素时效率还是很高的。

所以ArrayList比较常用。

import java.util.LinkedList;
import java.util.List;
public class LinkedListTest01 {
    public static void main(String[] args) {
        List list = new LinkedList();
        list.add("ice");
        list.add("coffee");
        for (int i = 0; i < list.size(); i++) {
            System.out.printf(list.get(i) + " ");
        }
    }
}

5.List实现类——Vector

Vector底层也是一个数组，初始化容量为10。
扩容：扩容之后是原容量的2倍。
Vector中所有方法都是线程同步的，都带有synchronized关键字，是线程安全的，效率比较低，使用较少。


import java.util.Iterator;
import java.util.Vector;

public class VectorTest {
    public static void main(String[] args) {
        Vector vector = new Vector();
        vector.add(1);
        vector.add(2);
        vector.add(3);
        vector.add(4);
        vector.add(5);
        vector.add(6);
        vector.add(7);
        vector.add(8);
        vector.add(9);
        vector.add(10);

        Iterator it = vector.iterator();

        while(it.hasNext()){
            Object obj = it.next();
            System.out.printf(obj + " ");  //1 2 3 4 5 6 7 8 9 10 
        }
        
    }
}

6.机制补充—泛型

JDK5.0后推出的新特性：泛型
在没有使用泛型时，it.next()取出来的是Object类型，使用起来不方便。

public class GenericTest {
    public static void main(String[] args) {
        List myList = new ArrayList();
        
        Cat c = new Cat();
        Bird b = new Bird();
        
        myList.add(c);
        myList.add(b);
        
        Iterator it = myList.iterator();
        while(it.hasNext()){

            // Animal a = it.next();迭代器取出的是Object，所以这么写会报错
            Object obj = it.next();
            if(obj instanceof Animal){
                Animal a = (Animal)obj;
                a.move();
            }
        }
    }
}
class Animal{
    public void move(){
        System.out.println("动物在移动");
    }
}
class Cat extends Animal{
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}
class Bird extends Animal{
    public void fly(){
        System.out.println("鸟在飞");
    }
}

在JDK5之后泛型机制，表示List中只允许存储某个类型(例如Animal)的数据，语法：List<Animal>；
使用泛型，集合中元素类型能够统一。

public class GenericTest {
    public static void main(String[] args) {
        List<Animal> myList = new ArrayList<Animal>();
        Cat c = new Cat();
        Bird b = new Bird();
        myList.add(c);
        myList.add(b);
        //myList.add("abc");只能存储Animal类型的数据，不允许存储String或其他类型

        //这个表示迭代器迭代的是Animal类型
        Iterator<Animal> it = myList.iterator();
        while(it.hasNext()){
            //使用泛型后，每一次迭代返回的数据都是Animal类型
            Animal a =it.next();
            //不需要强制类型转换，直接调用
            a.move();
        }
    }
}
class Animal{
    public void move(){
        System.out.println("动物在移动");
    }
}
class Cat extends Animal{
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}
class Bird extends Animal{
    public void fly(){
        System.out.println("鸟在飞");
    }
}

JDK8后引入，自动类型推断机制（即钻石表达式）：List<Animal> myList = new ArrayList<>();

public class GenericTest {
    public static void main(String[] args) {
        List<Animal> myList = new ArrayList<>();
        myList.add(new Animal());
        myList.add(new Cat());
        myList.add(new Bird());
        //myList.add("abc");只能存储Animal类型的数据，不允许存储String或其他类型
        Iterator<Animal> it = myList.iterator();
        while(it.hasNext()){
            Animal a = it.next();
            a.move();
        }
    }
}

可以自定义泛型，自定义泛型时<>里边是一个标识符，可以随便写。一般写<T>或者写<E>

public class GenericTest<E> {
    public void doSome(E o){
        System.out.println(o);
    }
    public static void main(String[] args) {
        GenericTest<String> gt = new GenericTest<>();
        gt.doSome("icecoffee");
        //gt.doSome(123); 报错，类型不匹配

        GenericTest<Integer> gt2 = new GenericTest<>();
        //gt2.doSome("icecoffee");报错，类型不匹配
        gt2.doSome(123);
    }
}

7.增强for循环foreach

增强for（foreach）语法：变量名是用来标记数组中的元素。

for(元素类型变量名 : 数组名){ }

public class ForEachTest {
    public static void main(String[] args) {
        int[] arr = {123,11,4,1453,45,21};
        for(int data : arr){
            System.out.printf(data + " "); //123 11 4 1453 45 21 
        }
    }
}

foreach有一个缺点：没有下标，在需要使用下标的循环中，不建议使用foreach

public class ForEachTest {
    public static void main(String[] args) {
        List<String> myList = new ArrayList<>();
        myList.add("ice");
        myList.add("coffee");
        myList.add("is");
        myList.add("nice");
        for (String s: myList) {
            System.out.printf(s + " ");  //ice coffee is nice 
        }
    }
}

8.Set常用方法

HashSet集合元素：存入时与取出时不一定一样，可重复，没有下标。

public class SetTest {
    public static void main(String[] args) {
        Set<String> strs = new HashSet<>();
        //HashSet中add实际上是存储到HashMap的key部分。
        strs.add("ice");
        strs.add("coffee");
        strs.add("coffee");
        strs.add("very");
        strs.add("good");
        strs.add("very");
        strs.add("good");

        for (String s:
             strs) {
            System.out.printf(s + " "); //very coffee ice good 
        }
    }
}

TreeSet集合：存入时与取出时不一定一样，不可重复，没有下标。但是存储的元素自动按照大小排序。

public class SetTest {
    public static void main(String[] args) {
        Set<String> strs = new TreeSet<>();
        strs.add("A");
        strs.add("C");
        strs.add("V");
        strs.add("R");
        strs.add("N");
        strs.add("J");
        strs.add("O");

        for (String s:
                strs) {
            System.out.printf(s + " "); //A C J N O R V
        }
    }
}

——本章节为个人学习笔记。学习视频为动力节点Java零基础教程视频：动力节点—JAVA零基础教程视频

文章来源:https://blog.csdn.net/weixin_46016581/article/details/135604808
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：chenni525@qq.com进行投诉反馈，一经查实，立即删除！