day18-

day18-

Java集合01

1.什么是集合?

前面我们保存数据使用的是数组,数组有不足的地方,我们来分析一下:

  1. 长度开始时必须指定,而且一但指定不能更改
  2. 保存的必须是同一类型的元素
  3. 使用数组进行增加/删除元素的很麻烦----重新创建一个数组,将旧数组的元素拷贝过来
  • 集合的好处:
    • 可以动态地保存任意多个对象,使用比较方便
    • 提供了一系列方便的操作对象的方法:add、remove、set、get等
    • 使用集合添加、删除新元素简单高效

1.1集合的框架体系

  1. 集合主要是两组(单列集合,双列集合)
  2. Collection接口有两个重要的子接口List和Set,它们的实现子类都是单列集合
  3. Map接口的实现子类 是双列集合,存放的是 K-V

例子

package li.collections;
import java.util.*;

public class CollectionsTest {
    public static void main(String[] args) {
        //Collection
        //Map

        ArrayList arrayList = new ArrayList();
        arrayList.add("jack");//单列
        arrayList.add("tony");

        HashMap hashMap = new HashMap();
        hashMap.put("No1","北京");//双列
        hashMap.put("No2","上海");      
    }

}

2.Collection接口

  • Collection接口实现类的特点
public interface Collecion<E> extends Iterable<E>
  1. Collection 实现子类可以存放多个元素,每个元素可以是Object
  2. Collection的实现类,有些可以存放重复的元素,有些不可以
  3. Collection的实现类,有些是有序的(List),有些是无序的(Set)
  4. Collection接口没有直接实现的子类,是通过它的子接口List和Set来实现的

2.1Collection方法

  1. add()添加单个元素
  2. remove()删除指定元素
  3. contains()查找元素是否存在
  4. size()获取元素个数
  5. isEmpty()判断是否为空
  6. clear()清空
  7. addAll()添加多个元素
  8. containsAll()查找多个元素是否都存在
  9. removeAll()删除多个元素

例子1:Collection接口不能直接被实例化,因此以实现了接口的子类ArrayList来演示

package li.collections;
import java.util.*;

public class CollectionMethod {
    public static void main(String[] args) {
        List list = new ArrayList();

        //1. add()添加单个元素
        list.add("jack");
        list.add(10);//list.add(new Integer(10)); 自动装箱
        list.add(true);
        System.out.println("list="+list);//list=[jack, 10, true]  注意里面的元素都是对象,非基本数据类型

        //2. remove()删除指定元素
        //list.remove(0);//指定删除的索引
        //System.out.println("list="+list);//list=[10, true]
        list.remove(true);//指定删除某个对象
        System.out.println("list="+list);//list=[jack, 10]

        //3. contains()查找元素是否存在
        System.out.println(list.contains("jack"));//true

        //4. size()获取元素个数
        System.out.println(list.size());//2

        //5. isEmpty()判断是否为空
        System.out.println(list.isEmpty());//false

        //6. clear()清空
        list.clear();
        System.out.println(list);//[]  空的集合

        //7. addAll()添加多个元素
        ArrayList list2 =new ArrayList();
        list2.add("红楼梦");
        list2.add("三国演义");
        list.addAll(list2);
        System.out.println("list="+list);//list=[红楼梦, 三国演义]

        //8. containsAll()查找多个元素是否都存在
        System.out.println(list.containsAll(list2));//true

        //9. removeAll()删除多个元素
        list.add("聊斋志异");
        list.removeAll(list2);
        System.out.println("list="+list);//list=[聊斋志异]

    }

}

3.迭代器遍历

  • 迭代:即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素,如果有,就把这个元素取出来,继续再判断,如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

  • 基本介绍:

  1. Iterator对象称为迭代器,主要用于遍历Collection集合中的元素。
  2. 所有实现了Collection接口的集合类都有一个iterator()方法,用以返回一个实现了Iterator接口的对象,即可以返回一个迭代器
  3. Iterator仅用于遍历集合,Iterator本身并不存放对象
  • Iterator接口的常用方法如下:
    • public E next():返回迭代的下一个元素。
    • public boolean hasNext():如果仍有元素可以迭代,则返回 true。
    • default void remove():
  • 迭代器的执行原理:

PS:在调用iterator.next()方法之前一定必须要调用iterator.hasNext()方法来进行检测,若不调用且下一条记录无效则会抛出 NoSuchElementException 异常。

例子:

package li.collections;

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

public class CollectionIterator {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        Collection col = new ArrayList();

        col.add(new Book("三国演义","罗贯中",10.1));
        col.add(new Book("小李飞刀","古龙",5.1));
        col.add(new Book("红楼梦","曹雪芹",34.6));

        System.out.println("col"+col);//col[Book{name="三国演义", author="罗贯中", price=10.1}, Book{name="小李飞刀", author="古龙", price=5.1}, Book{name="红楼梦", author="曹雪芹", price=34.6}]

        //现在想要遍历这个col集合
        //1.先得到col集合对应的迭代器
        
        Iterator iterator = col.iterator();
        
        //2.使用while循环遍历
        while (iterator.hasNext()) {
            Object next =  iterator.next();
            System.out.println(next);
        }
        //3.当退出while循环之后,这使得iterator迭代器指向最后的元素,
        // 这时如果再执行iterator.next()就会出现NoSuchElementException异常
        //4.如果想要再次遍历集合,则需要重置迭代器
        //重置迭代器,这之后就可以再次遍历,实质上是重新创建了一个迭代器对象
        iterator = col.iterator();
    }

}

class Book{
    private String name;
    private String author;
    private double price;

    public Book(String name, String author, double price) {
        this.name = name;
        this.author = author;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name="" + name + """ +
                ", author="" + author + """ +
                ", price=" + price +
                "}";
    }
}
image-20220809182558409

快捷键:itit

image-20220809182350682 image-20220809182425707

快捷键:Ctrl+j 显示所有快捷键

image-20220809182807590

4.集合增强

  • Collection接口遍历对象的方式1--迭代器遍历 2--for循环增强

  • 增强for循环,可以代替iterator迭代器,特点:增强for循环就是简化版的iterator,本质一样。只能用于遍历集合或者数组。

  • 基本语法:

    for(元素类型 元素名:集合名或数组名){
        访问元素
    }
    

    例子:

    package li.collections;
    import java.util.ArrayList;
    import java.util.Collection;
    
    public class CollectionFor {
        @SuppressWarnings({"all"})
        public static void main(String[] args) {
            Collection col = new ArrayList();
    
            col.add(new Book("三国演义","罗贯中",10.1));
            col.add(new Book("小李飞刀","古龙",5.1));
            col.add(new Book("红楼梦","曹雪芹",34.6));
    
            //增强for,用于集合
            //增强for底层仍然是迭代器
            //因此增强for可以理解成简化版的迭代器
            for (Object book:col) {//元素类型 元素名:集合名或数组名
                System.out.println("book="+book);
            }
    
            //使用增强for,不但可以适用于集合,还可以用于数组
    
            int[] nums ={1,3,8,10};
            for (int i:nums){
                System.out.println("i="+i);
            }
        }
    }
    
    image-20220809185952366

快捷键:集合名.for

image-20220809190200623 image-20220809190106280

5.List接口

List接口是Collection接口的子接口

  • List集合类中的元素有序(即添加顺序和取出顺序一致),且可重复
  • List集合中的每个元素都有其对应的顺序索引,即支持索引
  • List容器中的元素都对应一个整数型序号记载在其容器中的位置,可以根据序号存取容器中的元素
  • JDK API中List接口的实现子类有很多,常用的有ArrayList、LinkedList和Vector
image-20220809203135467

5.1List接口的常用方法

  1. boolean add(int index, E element) 将指定的元素插入此列表中的指定位置(可选操作)

  2. boolean addAll(int index, Collection<? extends E> c) 将指定集合中的所有元素插入到此列表中的指定位置(可选操作)

  3. Obect get(int index) 返回此列表中指定位置的元素

  4. int indexOf(Object o) 返回此列表中指定元素的第一次出现的索引,如果此列表不包含元素,则返回-1

  5. int lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引,如果此列表不包含元素,则返回-1

  6. Object remove(int index) 删除该列表中指定位置的元素,并返回此元素(可选操作)

  7. Object set(int index, E element) 用指定的元素(可选操作)替换此列表中指定位置的元素

  8. List subList(int fromIndex, int toIndex) 返回从 fromIndex(不含)到 toIndex(不含)位置的子集合:[fromIndex,toIndex)

例子:

package li.collections.list;

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

public class ListMethod {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("张三丰");
        list.add("贾宝玉");

        //boolean add(int index, E element)
        //将指定的元素插入此列表中的指定位置(可选操作)
        list.add(1,"杨过");//在index=1的位置插入一个对象
        System.out.println(list);//[张三丰, 杨过, 贾宝玉]

        //boolean addAll(int index, Collection<? extends E> c)
        //将指定集合中的所有元素插入到此列表中的指定位置(可选操作)
        List list2 = new ArrayList();
        list2.add("jack");
        list2.add("tom");
        list.addAll(1,list2);//在索引1位置插入list2集合的元素
        System.out.println(list);//[张三丰, jack, tom, 杨过, 贾宝玉]

        //Obect get(int index)
        // 返回此列表中指定位置的元素。

        //int indexOf(Object o)
        //返回此列表中指定元素的第一次出现的索引,如果此列表不包含元素,则返回-1
        System.out.println(list.indexOf("tom"));//2

        //int lastIndexOf(Object o)
        //返回此列表中指定元素的最后一次出现的索引,如果此列表不包含元素,则返回-1
        list.add("杨过");
        System.out.println(list);//[张三丰, jack, tom, 杨过, 贾宝玉, 杨过]
        System.out.println(list.lastIndexOf("杨过"));//5

        //Object remove(int index)
        //删除该列表中指定位置的元素,并返回此元素(可选操作)
        list.remove(3);
        System.out.println(list);//[张三丰, jack, tom, 贾宝玉, 杨过]

        //Object set(int index, E element)
        //用指定的元素(可选操作)替换此列表中指定位置的元素
        list.set(1,"马丽");
        System.out.println(list);//[张三丰, 马丽, tom, 贾宝玉, 杨过]

        //List subList(int fromIndex, int toIndex)
        //返回从 fromIndex(不含)到 toIndex(不含)位置的子集合:[fromIndex,toIndex)
        List returnList = list.subList(0,2);
        System.out.println(returnList);//[张三丰, 马丽]


    }
}

5.2List的三种遍历方式

List的三种遍历方式:

  1. 使用iterator迭代器
  2. 使用增强for循环
  3. 使用for循环

例子:

package li.collections.list;

import java.util.*;

public class ListFor {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {

        //List接口的实现子类 Vector LinkedList同理
        
        //List list = new ArrayList();
        //List list = new Vector();
        List list = new LinkedList();
        list.add("jack");
        list.add("tom");
        list.add("鱼香肉丝");
        list.add("北京烤鸭");

        //1.使用迭代器
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object obj =  iterator.next();
            System.out.print(obj);
        }

        //2.增强for循环
        for (Object obj:list) {
            System.out.print(obj);
        }

        //使用普通for循环
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i));
        }
    }
}
image-20220809213128753

5.3List排序练习

使用List的实现类添加三本图书,并遍历,打印效果如下:

名称:XX 价格:xx 作者:xx

名称:XX 价格:xx 作者:xx

名称:XX 价格:xx 作者:xx

要求:

  1. 按价格排序,从低到高(使用冒泡排序)

  2. 要求使用ArrayList、LinkedList、Vector三种集合实现

使用冒泡实现集合的排序

package li.collections.list;

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

@SuppressWarnings("all")
public class ListExercise {

    public static void main(String[] args) {

        //使用ArrayList,LinkedList、Vector同理
        List list = new ArrayList();
        list.add(new Book("红楼梦", 65.5, "曹雪芹"));
        list.add(new Book("西游记", 48.8, "吴承恩"));
        list.add(new Book("三国演义", 55, "罗贯中"));
        list.add(new Book("水浒传", 36, "施耐庵"));


        System.out.println("====未排序前遍历====");
        for (Object o : list) {
            System.out.println(o);
        }

        sort(list);

        System.out.println("====排序后遍历====");
        for (Object o : list) {
            System.out.println(o);
        }


    }

    //对集合进行排序
    public static void sort(List list) {
        int listSize = list.size();//获取集合的长度
        Book book1;
        Book book2;
        for (int i = 0; i < listSize - 1; i++) {//轮数
            for (int j = 0; j < listSize - 1 - i; j++) {//每轮的索引
                book1 = (Book) list.get(j);
                book2 = (Book) list.get(j + 1);
                if (book1.getPrice() > book2.getPrice()) {
                    list.set(j, book2);
                    list.set(j + 1, book1);
                }

            }
        }


    }
}


class Book {
    private String name;
    private double price;
    private String author;

    public Book() {
    }

    public Book(String name, double price, String author) {
        this.name = name;
        this.price = price;
        this.author = author;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    @Override
    public String toString() {//按格式重写toString方法
        return "名称:" + name + "		" + "价格:" + price + "		" + "作者:" + author;
    }
}
image-20220810171406244

原文地址:https://www.cnblogs.com/liyuelian/archive/2022/08/10/16573206.html