java基础——随笔01

清疚 2023-10-16 10:13 38阅读 0赞

数组实例：
    
    
    package org.example.common;
    
    public class ZongJie {
    
        // 数组作为函数参数
        public static void printArray(int[] array)
        {
            System.out.println(array.length);
            System.out.println("--------------------111");
    
            System.out.println(array[0]);
            System.out.println(array[1]);
            System.out.println("--------------------222");
    
            for (int i=0;i<array.length;i++)
            {
                System.out.println(array[i]);
            }
    
            System.out.println("--------------------333");
        }
    
    
    
        //  数组作为函数返回值
        public static int[] calculate(int a,int b,int c)
        {
            int sum = a+b+c;
            int avg = sum/3;
    
            int[] array = {sum,avg};
    
            System.out.println(array[0]);
            System.out.println(array[1]);
    
            return  array;
        }
    
    
    
        public static void main(String[] args) {
    
            int[] as = new int[4];    //   数组动态初始化，方式一
    
            as[0] = 1;
            as[1] = 2;
            as[2] = 3;
            as[3] = 4;
    
    
            int[] ad;                //数组动态初始化，方式二
            ad = new int[10];
    
            // -------------------------------------------------------------
    
            String[] ab = {"a","b","c","d"};    //    数据静态初始化，指定长度
    
            int[] aw = new int[] {1,2,3,4,5,6,7,8};    //    数据静态初始化，指定长度     --此为上一行模式的省略模式
    
            // -------------------------------------------------------------
    
    
            printArray(aw);     //  函数调用，数组作为参数；
    
    
            // -------------------------------------------------------------
    
    
            System.out.println(calculate(1,2,3).length);     //函数调用，数组作为返回值；
    
    
        }
    
    
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    ==============================================================================================================================
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    循环实例
    
    
    
    
    
    
    
    
    package org.example.common.foruse;
    
    public class ForUse {
    
        public static void main(String[] args) {
    
    
            for(int i=10;i<20;i++)
            {
                System.out.println(i);
            }
    
            System.out.println("---------------------000");
    
            int i = 2;
            while (i<10){
                System.out.println(i);
                i++;
            }
    
            System.out.println("---------------------111");
    
            int j=2;
            do{
                System.out.println(j);
                j++;
    
            }while (j<5);
    
    
    
    
        }
    
    
    
    
    
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    ==============================================================================================================================
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    对象
    
    
    
    
    
    
    
    package org.example.common;
    
    public class Product {
    
        String name;
    
        int price;
    
        public Product(String name, int price) {
            this.name = name;
            this.price = price;
        }
    
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getPrice() {
            return price;
        }
    
        public void setPrice(int price) {
            this.price = price;
        }
    
        @Override
        public String toString() {
            return "Product{" +
                    "name='" + name + '\'' +
                    ", price=" + price +
                    '}';
        }
    
    
    
    
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    ==============================================================================================================================
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    List——arraylist——01
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    package org.example.common.list;
    
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    
    
    
    
    
    
    
    /**
     * java.util.List接口 extends Collection接口
     *
     * List接口的特点:
     * 1.有序的集合,存储元素和取出元素的顺序是一致的(存储123 取出123)
     * 2.有索引,包含了一些带索引的方法
     * 3.允许存储重复的元素
     *
     * List接口中带索引的方法(特有)
     *
     * public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
     * public E get(int index):返回集合中指定位置的元素。
     * public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
     * public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
     *
     * 注意:
     * 操作索引的时候,一定要防止索引越界异常
     *
     * IndexOutOfBoundsException:索引越界异常,集合会报
     * ArrayIndexOutOfBoundsException:数组索引越界异常
     * StringIndexOutOfBoundsException:字符串索引越界异常
     *
     *
     *
     * LinkedList集合
     *
     * java.util.LinkedList集合 implements List接口
     * ##** LinkedList集合的特点:**
     * 1.底层是一个链表结构:查询慢,增删快
     * 2.里边包含了大量操作首尾元素的方法
     * 注意:使用LinkedList集合特有的方法,不能使用多态
     *
     * public void addFirst(E e):将指定元素插入此列表的开头。
     *
     * public void addLast(E e):将指定元素添加到此列表的结尾。
     *
     * public void push(E e):将元素推入此列表所表示的堆栈。
     *
     * public E getFirst():返回此列表的第一个元素。
     *
     * public E getLast():返回此列表的最后一个元素。
     *
     * public E removeFirst():移除并返回此列表的第一个元素。
     *
     * public E removeLast():移除并返回此列表的最后一个元素。
     *
     * public E pop():从此列表所表示的堆栈处弹出一个元素。
     *
     * public boolean isEmpty()：如果列表不包含元素，则返回true。
     *
     */
    
    
    
    
    
    
    
    
    
    
    public class DemoListArrayList
    {
    
        public static void main(String[] args) {
            //创建一个List集合对象,多态
            List<String> list = new ArrayList<>();
    
            //使用add方法往集合中添加元素
            list.add("a");
            list.add("b");
            list.add("c");
            list.add("d");
            list.add("a");
    
            //打印集合
            System.out.println(list);           //[a, b, c, d, a]  不是地址，是因为重写了toString
    
    
    
    
            //public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
            //在c和d之间添加一个itheima
            list.add(3, "itheima");      //[a, b, c, itheima, d, a]
            System.out.println(list);
    
    
    
    
    
            //public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
            //移除元素
            String removeE = list.remove(2);
            System.out.println("被移除的元素:" + removeE);          //被移除的元素:c
            System.out.println(list);         //[a, b, itheima, d, a]
    
    
    
    
    
            //public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
            //把最后一个a,替换为A
            String setE = list.set(4, "A");
            System.out.println("被替换的元素:" + setE);         //被替换的元素:a
            System.out.println(list);        //[a, b, itheima, d, A]
    
    
    
    
    
            //List集合遍历有3种方式
            //使用普通的for循环
            for (int i = 0; i < list.size(); i++) {
                //public E get(int index):返回集合中指定位置的元素。
                String s = list.get(i);
                System.out.println(s);
            }
    
            System.out.println("-----------------");
    
    
            //使用迭代器
            Iterator<String> it = list.iterator();
            while (it.hasNext())
            {
                String s = it.next();
                System.out.println(s);
            }
    
    
        }
    
    
    }
    
    
    
    
    
    
    
    
    
    
    
    
    ==============================================================================================================================
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    List——arraylist——02
    
    
    
    
    
    
    
    
    
    
    package org.example.common.listuse;
    
    import org.example.common.Product;
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    public class ListUse{
    
        public static void main(String[] args) {
    
    
            List<Integer> list = new ArrayList<Integer>();
    
            list.add(1);
            list.add(2);
            list.add(3);
            list.add(4);
            list.add(5);
    
            System.out.println(list);        //     [1, 2, 3, 4, 5]
    
            System.out.println("------------------------");
    
    
    
    
    
            System.out.println(list.size());    //    5
            
            System.out.println(list.get(0));   //   1
            System.out.println(list.get(4));      //    5
    
            System.out.println("-------------------000");
    
    
    
    
            for (int i=0;i<list.size();i++){            
                System.out.println(list.get(i));
            }
    
            /**
             * 1
             * 2
             * 3
             * 4
             * 5
             */
    
            System.out.println("-----------------111");
    
    
    
    
    
    
    
    
    
    
    
    
    
            List listProduct = new ArrayList<Product>();
    
            Product product001 = new Product("ma001",100);
            Product product002 = new Product("ma002",100);
            Product product003 = new Product("ma003",100);
            Product product004 = new Product("ma004",100);
            Product product005 = new Product("ma005",100);
    
            listProduct.add(product001);
            listProduct.add(product002);
            listProduct.add(product003);
            listProduct.add(product004);
            listProduct.add(product005);
    
            System.out.println(listProduct.get(0));   
            System.out.println(listProduct.get(4));   
    
            System.out.println(listProduct);
    
            /**
             * Product{name='ma001', price=100}
             * Product{name='ma005', price=100}
             * [Product{name='ma001', price=100}, Product{name='ma002', price=100}, Product{name='ma003', price=100}, Product{name='ma004', price=100}, Product{name='ma005', price=100}]
             * 
             */
    
            System.out.println("-----------------------222");
    
    
    
    
    
    
    
    
    
    
    
    
    
            Iterator it = listProduct.iterator();
    
            while (it.hasNext()){
    
                Product ww = (Product)it.next();
    
                System.out.println(ww.getName()+"     "+ww.getPrice());
    
            }
    
            /**
             * ma001     100
             * ma002     100
             * ma003     100
             * ma004     100
             * ma005     100
             */
    
    
            System.out.println("--------------------------------333");
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
            List<Product> as = new ArrayList<Product>();
    
            Product product006 = null;
    
            as.add(product006);
    
            System.out.println(as.size());
    
            System.out.println(as.get(0));
    
    
            /**
             * 1
             * null
             * 
             */
    
            System.out.println("----------------------------------------------------------");
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
            Iterator itt = listProduct.iterator();
    
            while (itt.hasNext()){
    
                System.out.println(itt.next());
    
            }
    
            /**
             * 
             * Product{name='ma001', price=100}
             * Product{name='ma002', price=100}
             * Product{name='ma003', price=100}
             * Product{name='ma004', price=100}
             * Product{name='ma005', price=100}
             */
    
    
    
    
    
        }
    
    
    
    
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    ==============================================================================================================================
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    Linkedlist——实例001
    
    
    
    
    
    
    
    
    
    
    
    package org.example.common.list;
    
    import java.util.LinkedList;
    
    /**
     * java.util.LinkedList集合 implements List接口
     *
     * ##** LinkedList集合的特点:**
     * 1.底层是一个链表结构:查询慢,增删快
     * 2.里边包含了大量操作首尾元素的方法
     * 注意:使用LinkedList集合特有的方法,不能使用多态
     *
     *
     *
     * public void addFirst(E e):将指定元素插入此列表的开头。
     *
     * public void addLast(E e):将指定元素添加到此列表的结尾。
     *
     * public void push(E e):将元素推入此列表所表示的堆栈。
     *
     * public E getFirst():返回此列表的第一个元素。
     *
     * public E getLast():返回此列表的最后一个元素。
     *
     * public E removeFirst():移除并返回此列表的第一个元素。
     *
     * public E removeLast():移除并返回此列表的最后一个元素。
     *
     * public E pop():从此列表所表示的堆栈处弹出一个元素。
     *
     * public boolean isEmpty()：如果列表不包含元素，则返回true。
     */
    
    public class DemoListLinkedList
    {
    
        public static void main(String[] args)
        {
    
            show03();
            System.out.println("--------------------");
            show02();
            System.out.println("--------------------");
            show01();
    
        }
    
        /*
            - public E removeFirst():移除并返回此列表的第一个元素。
            - public E removeLast():移除并返回此列表的最后一个元素。
            - public E pop():从此列表所表示的堆栈处弹出一个元素。此方法相当于 removeFirst
         */
    
    
        private static void show03()
        {
            //创建LinkedList集合对象
            LinkedList<String> linked = new LinkedList<>();
    
            //使用add方法往集合中添加元素
            linked.add("a");
            linked.add("b");
            linked.add("c");
    
            System.out.println(linked);     //[a, b, c]
    
            //String first = linked.removeFirst();
            String first = linked.pop();
            System.out.println("被移除的第一个元素:"+first);
    
            String last = linked.removeLast();
            System.out.println("被移除的最后一个元素:"+last);
    
            System.out.println(linked);//[b]
        }
    
    
    
        /*
            - public E getFirst():返回此列表的第一个元素。
            - public E getLast():返回此列表的最后一个元素。
         */
    
        private static void show02()
        {
    
            //创建LinkedList集合对象
            LinkedList<String> linked = new LinkedList<>();
    
            //使用add方法往集合中添加元素
            linked.add("a");
            linked.add("b");
            linked.add("c");
    
            //linked.clear();//清空集合中的元素 在获取集合中的元素会抛出NoSuchElementException
    
            //public boolean isEmpty()：如果列表不包含元素，则返回true。
            if(!linked.isEmpty())
            {
                String first = linked.getFirst();
                System.out.println(first);//a
    
                String last = linked.getLast();
                System.out.println(last);//c
            }
    
        }
    
    
    
    
        /*
            - public void addFirst(E e):将指定元素插入此列表的开头。
            - public void addLast(E e):将指定元素添加到此列表的结尾。
            - public void push(E e):将元素推入此列表所表示的堆栈。此方法等效于 addFirst(E)。
         */
    
        private static void show01()
        {
    
            //创建LinkedList集合对象
            LinkedList<String> linked = new LinkedList<>();
    
            //使用add方法往集合中添加元素
            linked.add("a");
            linked.add("b");
            linked.add("c");
            System.out.println(linked);//[a, b, c]
    
            //public void addFirst(E e):将指定元素插入此列表的开头。
            //linked.addFirst("www");
            linked.push("www");
            System.out.println(linked);//[www, a, b, c]
    
            //public void addLast(E e):将指定元素添加到此列表的结尾。此方法等效于 add()
            linked.addLast("com");
            System.out.println(linked);//[www, a, b, c, com]
    
    
        }
    
    
    
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    ==============================================================================================================================
    
    
    
    
    
    
    
    
    
    
    Linkedlist——实例002
    
    
    
    
    
    
    
    
    
    
    
    package org.example.common;
    
    import java.util.Iterator;
    import java.util.LinkedList;
    
    public class ZongJie {
    
        public static void main(String[] args) {
    
            //创建LinkedList集合对象
            LinkedList<String> linked = new LinkedList<>();
    
    
    
            //使用add方法往集合中添加元素
            linked.add("a");
            linked.add("b");
            linked.add("c");
    
            System.out.println(linked);     //[a, b, c]
            System.out.println("----------------------------------111");
    
    
    
    
    
    
    
            Iterator it = linked.iterator();
            while (it.hasNext())
            {
                System.out.println(it.next());
            }
            System.out.println("----------------------------------222");
    
    
    
    
    
    
    
            //String first = linked.removeFirst();
            String first = linked.pop();
            System.out.println("被移除的第一个元素:"+first);
            System.out.println("----------------------------------333");
    
    
    
    
    
    
    
            String last = linked.removeLast();
            System.out.println("被移除的最后一个元素:"+last);
            System.out.println("----------------------------------444");
    
    
    
    
    
    
    
            System.out.println(linked);//[b]
            System.out.println("----------------------------------555");
    
        }
    
    
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    ==============================================================================================================================
    
    
    
    
    
    
    
    
    
    
    
    set集合
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    HashSet 基于 HashMap 来实现的，是一个不允许有重复元素的集合。
    HashSet 允许有 null 值。
    HashSet 是无序的，即不会记录插入的顺序。
    HashSet 不是线程安全的， 如果多个线程尝试同时修改 HashSet，则最终结果是不确定的。 您必须在多线程访问时显式同步对 HashSet 的并发访问。
    HashSet 实现了 Set 接口。
    
    
    
    
    
    
    
    package org.example.common.set;
    
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.Set;
    
    /**
     *Set集合的概述
     *
     * java.util.Set接口和java.util.List接口一样，同样继承自Collection接口，它与Collection接口中的方法基本一致，并没有对Collection接口进行功能上的扩充，只是比Collection接口更加严格了。
     *
     * 与List接口不同的是，Set接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。
     *
     *
     * Set集合有多个子类，这里我们介绍其中的java.util.HashSet、java.util.LinkedHashSet这两个集合。
     *
     * tips:Set集合取出元素的方式可以采用：迭代器、增强for。
     *
     *
     *
     *
     *
     *
     *HashSet集合介绍
     *
     * java.util.Set接口 extends Collection接口
     *
     * Set接口的特点:
     * 1.不允许存储重复的元素
     * 2.没有索引,没有带索引的方法,也不能使用普通的for循环遍历
     *
     * java.util.HashSet集合 implements Set接口
     *
     * HashSet特点:
     * 1.不允许存储重复的元素
     * 2.没有索引,没有带索引的方法,也不能使用普通的for循环遍历
     * 3.是一个无序的集合,存储元素和取出元素的顺序有可能不一致
     * 4.底层是一个哈希表结构(查询的速度非常的快)
     *
     *
     *
     */
    
    
    public class DemoSetHashSet
    {
    
        public static void main(String[] args) {
            Set<Integer> set = new HashSet<>();
            //使用add方法往集合中添加元素
            set.add(1);
            set.add(3);
            set.add(2);
            set.add(1);
    
    
            //使用迭代器遍历set集合
            Iterator<Integer> it = set.iterator();
    
            while (it.hasNext())
            {
    
                Integer n = it.next();
                System.out.println(n);  //1,2,3
            }
    
    
            //使用增强for遍历set集合
            System.out.println("-----------------");
            for (Integer i : set)
            {
    
                System.out.println(i);
    
            }
        }
    
    
    
    
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    ==============================================================================================================================
    
    
    
    
    
    
    
    
    
    
    package org.example.common;
    
    import java.util.Objects;
    
    public class Person {
    
        private String name;
        private int age;
    
        public Person() {
        }
    
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Person person = (Person) o;
            return age == person.age &&
                    Objects.equals(name, person.name);
        }
    
        @Override
        public int hashCode() {
    
            return Objects.hash(name, age);
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", 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;
        }
    
    
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    package org.example.common.set;
    
    import org.example.common.Person;
    
    import java.util.HashSet;
    
    /**
     *HashSet存储自定义类型元素
     *
     * HashSet存储自定义类型元素
     *
     * set集合必须元素唯一:
     *
     * 存储的元素(String,Integer,...Student,Person...),必  须重写hashCode方法和equals方法
     *
     * 要求:
     * 同名同年龄的人,视为同一个人,只能存储一次
     *
     *
     */
    
    
    public class DemoSetHashSetForOne {
    
    
        public static void main(String[] args) {
    
    
            //创建HashSet集合存储Person
            HashSet<Person> set = new HashSet<>();
    
            Person p1 = new Person("小美女",18);
            Person p2 = new Person("小美女",18);
            Person p3 = new Person("小美女",19);
    
            System.out.println(p1.hashCode());//1967205423
            System.out.println(p2.hashCode());//42121758
    
            System.out.println(p1==p2);//false
    
            System.out.println(p1.equals(p2));//false
    
            set.add(p1);
            set.add(p2);
            set.add(p3);
    
            System.out.println(set);
    
    
    
        }
    
    
    
    
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    package org.example.common.set;
    
    
    import java.util.HashSet;
    import java.util.LinkedHashSet;
    
    /**
     *
     * LinkedHashSet集合
     *
     * java.util.LinkedHashSet集合 extends HashSet集合
     *
     * LinkedHashSet集合特点:
     * 底层是一个哈希表(数组+链表/红黑树)+链表:多了一条链表(记录元素的存储顺序),保证元素有序
     *
     *
     *
     *
     *
     *
     */
    public class DemoSetLinkedHashSet {
    
    
        public static void main(String[] args) {
            HashSet<String> set = new HashSet<>();
            set.add("www");
            set.add("abc");
            set.add("abc");
            set.add("itcast");
            System.out.println(set);    //[abc, www, itcast] 无序,不允许重复
    
            LinkedHashSet<String> linked = new LinkedHashSet<>();
            linked.add("www");
            linked.add("abc");
            linked.add("abc");
            linked.add("itcast");
            System.out.println(linked);     //[www, abc, itcast] 有序,不允许重复
    
    
        }
    
    
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    ==============================================================================================================================
    
    
    
    
    
    
    
    map——01
    
    
    
    
    
    
    
    
    
    
    
    
    
    package org.example.common.map;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * Map集合的概述
     *
     * Map集合的特点
     * java.util.Map集合
     * Map集合的特点:
     * 1.Map集合是一个双列集合,一个元素包含两个值(一个key,一个value)
     * 2.Map集合中的元素,key和value的数据类型可以相同,也可以不同
     * 3.Map集合中的元素,key是不允许重复的,value是可以重复的
     * 4.Map集合中的元素,key和value是一一对应
     *
     *
     *Map常用子类——————————java.util.HashMap集合 implements Map接口
     *
     *
     *HashMap集合的特点:
     * 1.HashMap集合底层是哈希表:查询的速度特别的快
     *    JDK1.8之前:数组+单向链表
     *    JDK1.8之后:数组+单向链表|红黑树(链表的长度超过8):提高查询的速度
     *
     * 2.hashMap集合是一个无序的集合,存储元素和取出元素的顺序有可能不一致
     *
     *
     * java.util.LinkedHashMap集合 extends HashMap集合
     * LinkedHashMap的特点:
     * 1.LinkedHashMap集合底层是哈希表+链表(保证迭代的顺序)
     * 2.LinkedHashMap集合是一个有序的集合,存储元素和取出元素的顺序是一致的
     *
     *
     *
     *
     *
     *
     * Map接口中的常用方法
     *
     * Map接口中定义了很多方法，常用的如下：
     *
     * public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
     *
     * public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
     *
     * public V get(Object key)根据指定的键，在Map集合中获取对应的值。
     *
     * boolean containsKey(Object key)判断集合中是否包含指定的键。
     *
     * public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
     *
     * public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。
     *
     */
    
    
    
    
    public class DemoMap
    {
    
        private static void show02 ()
        {
    
            //创建Map集合对象
            Map<String, Integer> map = new HashMap<>();
    
            map.put("赵丽颖", 168);
            map.put("杨颖", 165);
            map.put("林志玲", 178);
    
            System.out.println(map);            //{林志玲=178, 赵丽颖=168, 杨颖=165}
    
    
    
            Integer v1 = map.remove("林志玲");
            System.out.println("v1:" + v1);             //v1:178
    
            System.out.println(map);//{赵丽颖=168, 杨颖=165}
    
    
    
            //int v2 = map.remove("林志颖");//自动拆箱  NullPointerException
    
            Integer v2 = map.remove("林志颖");
            System.out.println("v2:" + v2);                 //v2:null
    
            System.out.println(map);//{赵丽颖=168, 杨颖=165}
        }
    
    
    
        /*
            public V put(K key, V value):  把指定的键与指定的值添加到Map集合中。
                返回值:v
                    存储键值对的时候,key不重复,返回值V是null
                    存储键值对的时候,key重复,会使用新的value替换map中重复的value,返回被替换的value值
         */
    
        private static void show01 ()
        {
    
            //创建Map集合对象,多态
            Map<String, String> map = new HashMap<>();
    
            String v1 = map.put("李晨", "范冰冰1");
            System.out.println("v1:" + v1);                      //v1:null
    
            String v2 = map.put("李晨", "范冰冰2");
            System.out.println("v2:" + v2);                      //v2:范冰冰1
    
            System.out.println(map);//{李晨=范冰冰2}
    
            map.put("冷锋", "龙小云");
            map.put("杨过", "小龙女");
            map.put("尹志平", "小龙女");
            System.out.println(map);//{杨过=小龙女, 尹志平=小龙女, 李晨=范冰冰2, 冷锋=龙小云}
    
    
        }
    
    
        public static void main(String[] args)
        {
    
            show02();
    
    
            System.out.println("--------------");
    
    
            show01();
    
    
    
        }
    
    
    
    
    
    }
    
    
    
    
    
    
    
    
    {林志玲=178, 赵丽颖=168, 杨颖=165}
    v1:178
    {赵丽颖=168, 杨颖=165}
    v2:null
    {赵丽颖=168, 杨颖=165}
    --------------
    v1:null
    v2:范冰冰1
    {李晨=范冰冰2}
    {杨过=小龙女, 尹志平=小龙女, 李晨=范冰冰2, 冷锋=龙小云}
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    ====================================================================================================================
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    map——02
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    package org.example.common;
    
    import java.util.Objects;
    
    public class Person {
    
        private String name;
        private int age;
    
        public Person() {
        }
    
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Person person = (Person) o;
            return age == person.age &&
                    Objects.equals(name, person.name);
        }
    
        @Override
        public int hashCode() {
    
            return Objects.hash(name, age);
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", 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;
        }
    
    
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    package org.example.common.map;
    
    
    import org.example.common.Person;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    /**
     *
     *HashMap存储自定义类型键值
     *Map集合保证key是唯一的:
     *作为key的元素,必须重写hashCode方法和equals方法,以保证key唯一
     *
     */
    
    
    
    public class DemoMapForCustomObject {
    
    
        public static void main(String[] args) {
            show02();
            System.out.println("-----------------");
            show01();
        }
    
        /*
            HashMap存储自定义类型键值
            key:Person类型
                Person类就必须重写hashCode方法和equals方法,以保证key唯一
            value:String类型
                可以重复
         */
        private static void show02() {
    
    
            //创建HashMap集合
            HashMap<Person,String> map = new HashMap<>();
    
    
            //往集合中添加元素
            map.put(new Person("女王",18),"英国");
            map.put(new Person("秦始皇",18),"秦国");
            map.put(new Person("普京",30),"俄罗斯");
            map.put(new Person("女王",18),"毛里求斯");
    
    
            //使用entrySet和增强for遍历Map集合
            Set<Map.Entry<Person, String>> set = map.entrySet();
    
            for (Map.Entry<Person, String> entry : set) {
                Person key = entry.getKey();
                String value = entry.getValue();
                System.out.println(key+"-->"+value);
            }
        }
    
        /*
            HashMap存储自定义类型键值
            key:String类型
                String类重写hashCode方法和equals方法,可以保证key唯一
            value:Person类型
                value可以重复(同名同年龄的人视为同一个)
         */
        private static void show01() {
    
            //创建HashMap集合
            HashMap<String,Person> map = new HashMap<>();
    
    
            //往集合中添加元素
            map.put("北京",new Person("张三",18));
            map.put("上海",new Person("李四",19));
            map.put("广州",new Person("王五",20));
            map.put("北京",new Person("赵六",18));
    
    
            //使用keySet加增强for遍历Map集合
            Set<String> set = map.keySet();
    
            for (String key : set) {
                Person value = map.get(key);
                System.out.println(key+"-->"+value);
            }
        }
    
    
    
    
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    package org.example.common.map;
    
    
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    
    /**
     *
     *
     *Map集合遍历键找值方式
     *
     * Map集合的第一种遍历方式:通过键找值的方式
     *
     * Map集合中的方法:
     * SetkeySet() 返回此映射中包含的键的 Set 视图。
     * 实现步骤:
     * 1.使用Map集合中的方法keySet(),把Map集合所有的key取出来,存储到一个Set集合中
     * 2.遍历set集合,获取Map集合中的每一个key
     * 3.通过Map集合中的方法get(key),通过key找到value
     *
     *
     *
     *
     *
     */
    
    
    public class DemoMapUseKeyFindValueMethod {
    
        public static void main(String[] args)
        {
    
    
            //创建Map集合对象
            Map<String,Integer> map = new HashMap<>();
    
            map.put("赵丽颖",168);
            map.put("杨颖",165);
            map.put("林志玲",178);
    
    
            //1.使用Map集合中的方法keySet(),把Map集合所有的key取出来,存储到一个Set集合中
            Set<String> set = map.keySet();
    
            //2.遍历set集合,获取Map集合中的每一个key
            //使用迭代器遍历Set集合
            Iterator<String> it = set.iterator();
    
            while (it.hasNext())
            {
    
                String key = it.next();
    
                //3.通过Map集合中的方法get(key),通过key找到value
                Integer value = map.get(key);
    
                System.out.println(key+"="+value);
    
            }
    
            System.out.println("-------------------");
    
    
    
    
            //使用增强for遍历Set集合
            for(String key : set)
            {
    
                //3.通过Map集合中的方法get(key),通过key找到value
                Integer value = map.get(key);
                System.out.println(key+"="+value);
    
            }
    
    
            System.out.println("-------------------");
    
    
            //使用增强for遍历Set集合
            for(String key : map.keySet())
            {
    
                //3.通过Map集合中的方法get(key),通过key找到value
                Integer value = map.get(key);
                System.out.println(key+"="+value);
            }
        }
    
    
    
    
    
    
    
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    package org.example.common.map;
    
    
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    
    /**
     *
     * https://www.kancloud.cn/jysxr/yx101/2168759
     *Map集合遍历键值对方法
     *
     * Map集合遍历的第二种方式:使用Entry对象遍历
     *
     * Map集合中的方法:
     * Set> entrySet() 返回此映射中包含的映射关系的 Set 视图。
     *
     * 实现步骤:
     * 1.使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来,存储到一个Set集合中
     * 2.遍历Set集合,获取每一个Entry对象
     * 3.使用Entry对象中的方法getKey()和getValue()获取键与值
     *
     *
     */
    
    public class DemoMapUseKeyFindValueMethod002
    {
        public static void main(String[] args) {
    
    
            //创建Map集合对象
            Map<String,Integer> map = new HashMap<>();
    
    
            map.put("赵丽颖",168);
            map.put("杨颖",165);
            map.put("林志玲",178);
    
    
            //1.使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来,存储到一个Set集合中
            Set<Map.Entry<String, Integer>> set = map.entrySet();
    
            //2.遍历Set集合,获取每一个Entry对象
            //使用迭代器遍历Set集合
            Iterator<Map.Entry<String, Integer>> it = set.iterator();
    
            while(it.hasNext()){
                Map.Entry<String, Integer> entry = it.next();
    
                //3.使用Entry对象中的方法getKey()和getValue()获取键与值
                String key = entry.getKey();
                Integer value = entry.getValue();
                System.out.println(key+"="+value);
            }
    
    
            System.out.println("-----------------------");
    
    
            for(Map.Entry<String,Integer> entry:set){
    
                //3.使用Entry对象中的方法getKey()和getValue()获取键与值
                String key = entry.getKey();
                Integer value = entry.getValue();
    
                System.out.println(key+"="+value);
    
            }
        }
    
    }