java基础——随笔01

数组实例：


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);

        }
    }

}