Java学习Day07集合

最新推荐文章于 2024-08-03 21:02:21 发布

御狐王

最新推荐文章于 2024-08-03 21:02:21 发布

阅读量36

点赞数

文章标签： java 学习 windows

本文链接：https://blog.csdn.net/yuhuwangxy/article/details/132948778

版权

Java学习Day07集合List

List接口 Map接口以及常用子接口

在这里插入图片描述
ArrayList Vector LinkedList 三者都是List下的子类都能调用List的方法

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

public class Collection {
    @SuppressWarnings({"all"})//抑制警告数量
    public static void main(String[] args) {
        //集合主要分为2组 单列集合和双列集合
        //Collection 接口 List Set 他们的子类都是单列集合
        //List 有序 Set无序

        //Map 接口的实现 是双列集合 存放的是KV
        //new Arraylist().var
        ArrayList arrayList = new ArrayList();
        arrayList.add("jack");
        arrayList.add("tom");

        HashMap hashMap = new HashMap();
        hashMap.put("No1","A");
        hashMap.put("No2","B");
    }
    
}

ArrayList接口的一些方法

import java.util.List;
import java.util.ArrayList;
//类名不要和方法名重合
//重合调用方法需要java.util.ArrayList() 调用
public class ArrayListMethod {
    public static void main(String[] args) {
        List list = new ArrayList();
        //增加一个集合元素
        list.add("jack");
        list.add(10);
        list.add(true);
        //list.add(new Integer())不在是基本数据类型而是对象
        System.out.println("list= "+list);

        //list.remove(0);//删除第一个元素
        list.remove("jack");
        //list.remove(new Integer(10));//指定删除10
        list.remove(Integer.valueOf(10));//指定删除10，用这种方法上面的将要被淘汰
        //因为上面这种方法造成的性能浪费比较多
        //Java 11中已经弃用了new Byte()和new Integer()，应该是为了避免过多地创建对象。
        System.out.println("list= "+list);
        //检测是否含有元素 返回true或false
        System.out.println(list.contains(true));
        //检测集合元素个数
        System.out.println(list.size());
        //检测集合是否为空 
        System.out.println(list.isEmpty());

        //list.clear();将集合做空

        ArrayList list1 = new ArrayList();
        
        list1.add("A");
        list1.add("B");
        list.clear();
        list.addAll(list1);//在一个集合里增加另一个集合的所有元素
        System.out.println("list= "+list);
        //检查一个集合里是否包含另一个集合的所有元素
        System.out.println(list.containsAll(list1));
        //移除这个集合中的另一个集合的所有元素
        list.removeAll(list1);

        System.out.println("list= "+list);

    }
}

迭代器

import java.util.ArrayList;
import java.util.Collection;
public class Iterator {
    @SuppressWarnings({"all"})//减少警告
    public static void main(String[] args) {

        Collection col = new ArrayList();//必须调用上面两个包
        //父类引用指向子类
        col.add(new Book("三国演义","罗贯中",10));//增加集合元素
        col.add(new Book("红楼梦","曹雪芹",10));
        col.add(new Book("笑傲江湖","金庸",10));

        //System.out.println("col = "+col);
        //遍历
        //先得到集合的迭代器
        java.util.Iterator iterator = col.iterator();
        //while遍历
//        while(iterator.hasNext())//hasNext 判断是否有元素 返回true false
//        {   //编译类型是object 运行类型是真正的类型
//            Object object = iterator.next();
//            //返回元素类型是object
//            System.out.println("object = "+ object);
//        }
        //快捷键itit 显示所有快捷键 ctrl +j
        while (iterator.hasNext()) {
            Object object = iterator.next();
            System.out.println("object = "+ object);
        }
        //退出while循环后,这时iterator.next NoSuchElementException
        //iterator.next();
        //想要重新遍历 就需要重置迭代器
        iterator = col.iterator();
        while (iterator.hasNext()) {
            System.out.println("====================");
            Object next = iterator.next();
            System.out.println("object = "+ next);
        }

    }
    //调用 iterator.next(),要调用iterator.hasNext()检查元素是否存在
}

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 +
                '}';
    }
}

Exercise 创建一个集合并且输入至少三只狗的年龄名字并且两种方法遍历

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

public class CollectionExercise {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(new Dog("jack",1));
        list.add(new Dog("rose",3));
        list.add(new Dog("bob",2));
        //首先要读取到集合的迭代器
        java.util.Iterator iterator = list.iterator();

        while (iterator.hasNext()) {
            Object animal = iterator.next();
            System.out.println("animal "+animal);
        }
        System.out.println("================");
        for (Object o :list) {

            System.out.println("animal"+o);//实际上增强for也是迭代器 当你用debug force step into 就会发现for调用的iterator

        }
    }
}

class Dog{

    private String name;
    private int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

List集合

public class List_ {
    public static void main(String[] args) {
        //List集合类中元素有序且可重复
        List list = new ArrayList();
        list.add("jack");
        list.add("jack");
        list.add("tom");
        list.add("rose");
        System.out.println(list);
        //List集合每个元素都像数组一样有索引从0开始
        System.out.println(list.get(3));

    }
}

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

public class ListMethod {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("bob");
        list.add("chen");
        //在索引=1的位置插入一个对象
        list.add(1,"mpp");
        System.out.println("list" +list);

        List list1 = new ArrayList();
        list1.add("jack");
        list1.add("tom");
        list.addAll(1,list1);//在索引1的位置插入list1集合
        System.out.println("list"+list);
        System.out.println(list.indexOf("tom"));//输出tom的索引
        list.add("mpp");
        System.out.println(list.lastIndexOf("mpp"));//输出最后一个mpp的索引
        list.remove(0);//移除list集合的0
        System.out.println(list);
        list.set(1,"marin");//将索引为1的元素设置为marin
        System.out.println(list);
        List returnlist =list.subList(0,2);//将list第一个第二个的元素赋给新的returnlist集合
        System.out.println(returnlist);//左闭右开的区间
    }
}

Exercise 给一个集合至少10元素，重命名第二，八个元素输出第6个元素移除第7个元素并遍历

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

public class ListExercise {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("tom");
        list.add("jerry");
        list.add("rose");
        list.add("steven");
        list.add("bob");
        list.add("lisa");
        list.add("tina");
        list.add("baby");
        list.add("flower");
        list.add("qute");
        list.add("mina");
        list.add("tom");
        list.set(1,"yuh");
        System.out.println(list.get(5));
        list.remove(6);
        list.set(7,"sar");

        java.util.Iterator iterator = list.iterator();//获取到这个集合的迭代器
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.print(" "+next);
        }

    }

}

ArrayListDetial

//ArrayList可以有null元素可以有多个null
//ArrayList有数组实现存储
//ArrayList基本等同于Vector,但ArrayList线程不安全
//当然它执行效率高 多线程时不建议用ArrayList 多线程用Vector

public class ArrayListSource {
//ArrayList维护了一个object数组
    //当创建ArrayList对象时，使用的无参构造器初始elementData容量是0，第一次添加时，扩容10后续扩容为1.5
    //指定了大小如果需要扩容直接扩容1.5 15这种奇数向下取整就是22
    //transient表示瞬间的短暂的 表示该属性不会被序列化
public static void main(String[] args) {

    ArrayList list = new ArrayList();
//        public ArrayList() {
//        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
//    }
    for (int i = 0; i <= 10; i++) {
        list.add(i);
    }
    for (int i = 0; i <=15; i++) {
        list.add(i);
    }
    list.add(100);
    list.add(200);
    list.add(null);
}
}

Exercise02 做一个图书目录并以价格排序遍历

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

public class ListExercise02 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(new book("三国演义","罗贯中",10));
        list.add(new book("红楼梦","曹雪芹",15));
        list.add(new book("西游记","施耐庵",9.5));
 //排序源代码 写在main方法里不美观        
//        List list1 =new ArrayList();
//        for (int i = 0; i < list.size(); i++) {
//            for (int j = 0; j < list.size()-i-1; j++) {
//                book book1 = (book)list.get(j);
//                book book2 = (book)list.get(j+1);
//
//                if (book1.getPrice()>book2.getPrice()) {
//                    list1.add(0,list.get(j));
//                    list.set(j,list.get(j+1));
//                    list.set(j+1,list1.get(0));
//
//                }
//
//            }
//        }
        sort(list);
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next);
        }

    }

    public static void sort(List list){

        List list1 =new ArrayList();
                for (int i = 0; i < list.size(); i++) {
            for (int j = 0; j < list.size()-i-1; j++) {
                book book1 = (book)list.get(j);
                book book2 = (book)list.get(j+1);

                if (book1.getPrice()>book2.getPrice()) {
                    list1.add(0,list.get(j));
                    list.set(j,list.get(j+1));
                    list.set(j+1,list1.get(0));
                    //这里也可以用 list.set(j,book2);
                    //list.set(j+1,book1);
                    //当然上面的中间量定义和赋值就不需要了
                }

            }
        }

    }
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 +
                '}';
    }
}

VectorDetail

import java.util.Vector;

public class VectorSource {
    //Vector
    // public class Vector<E>
    //    extends AbstractList<E>
    //    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
    //也是一个对象数组
    //线程同步 线程安全 操作方法都带有synchronized
    //开发中做线程同步安全，考虑Vector
    /*
    * ArrayList
    * 可变数组     jdk1.2     不安全 效率高   创建无参10 1.5被扩容
    *
    * Vector
    * 可变数组     jdk1.0     安全效率不高    创建无参10 2倍扩容
    * */
    public static void main(String[] args) {

        Vector vector = new Vector();
        for (int i = 0; i < 10; i++) {
            vector.add(i);
        }
        vector.add(100);
//创建容量
//            public Vector() {
//            this(10);
//        }
//给Vector赋值
//        public synchronized boolean add(E e) {
//            modCount++;
//            add(e, elementData, elementCount);
//            return true;
//        }

    }
}

LinkedList

public class LinkedListMethod {
    //LinkedList底层实现双向列表 双端队列
    //可以添加任意元素 并且可以重复 包括null
    //线程不安全 没有实现重复
    //first last 分别指向首节点和尾节点 每一个节点node维护了prev next item 三个属性
    //prev指向前一个 next指向后一个实现双向链表
    //所有LinkedList添加和删除不是通过数组完成 相对效率较高
    public static void main(String[] args) {
        //模拟简单的双向链表
        Node jack = new Node("jack");
        Node tom = new Node("tom");
        Node yuh = new Node("yuh");
        //连接三个节点
        jack.next = tom;
        tom.next = yuh;
        yuh.prev = tom;
        tom.prev = jack;
        //现在就形成了双向链表
        Node first = jack;//双向链表的首节点
        Node last = yuh;//双向链表的尾节点
        //从头到尾遍历
        while(true){
            if (first == null){
                break;
            }
            System.out.println(first);
            first = first.next;
        }
        //从尾到头遍历
        System.out.println("==========");
        while(true){
            if (last == null){
                break;
            }
            System.out.println(last);
            last = last.prev;
        }
        System.out.println("============");
        //添加元素方便 在tom和yuh插入simth
        Node smith = new Node("smith");

        tom.next = smith;
        yuh.prev = smith;
        smith.next = yuh;
        smith.prev = tom;
        first = jack;
        while(true){
            if (first == null){
                break;
            }
            System.out.println(first);
            first = first.next;
        }

    }
}
class Node{
    public Object item;
    public Node next;
    public Node prev;
    public Node(Object name){
        this.item=name;
    }

    @Override
    public String toString() {
        return "Node name{" +
                "item=" + item +
                '}';
    }
}

LinkedListCRUD

import java.util.LinkedList;

//CRUD增删改查
public class LinkedListCRUD {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
//            public LinkedList() {
//        }
        //这时linkedList last first 都是null
        linkedList.add(1);
        linkedList.add(2);
        //执行add方法
        //    public boolean add(E e) {
        //        linkLast(e);
        //        return true;
        //    }
//        void linkLast(E e) {
//            final LinkedList.Node<E> l = last;
//            final LinkedList.Node<E> newNode = new LinkedList.Node<>(l, e, null);
//            last = newNode;
//            if (l == null)
//                first = newNode;
//            else
//                l.next = newNode;
//            size++;
//            modCount++;
//        }
        System.out.println(linkedList);
        linkedList.remove();//默认删除第一个
//    private E unlinkFirst(Node<E> f) {
//        // assert f == first && f != null;
//        final E element = f.item;
//        final Node<E> next = f.next;
//        f.item = null;
//        f.next = null; // help GC
//        first = next;
//        if (next == null)
//            last = null;
//        else
//            next.prev = null;
//        size--;
//        modCount++;
//        return element;
//    }
        System.out.println(linkedList);

    }
}