【JAVADAY11-集合、hashCode、hashMap实例详解】

arraysList

package ListApp;

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

public class List002 {
    public static void main(String[] args) {
        List arrayList = new ArrayList();
        //List取出顺序和添加顺序一致，可重复
        arrayList.add("zz");
        arrayList.add("hhh");
        arrayList.add("hhh");
        System.out.println(arrayList);
        //List的每个元素都有对应的索引
        System.out.println(arrayList.get(1));
        //插入索引为1的地方
        arrayList.add(1,"adwda");
        System.out.println(arrayList);
        //在某个位置加入多个
        ArrayList list = new ArrayList();
        list.add("qweqweqweqw");
        list.add("cxzcxzxzcxz");
        list.add("zz");
        arrayList.addAll(1,list);
        System.out.println(arrayList);
        //寻找索引位置的值
        System.out.println(arrayList.get(3));
        //寻找对象第一次出现的位置
        System.out.println(arrayList.indexOf("zz"));
        //寻找最后一次出现的位置
        System.out.println(arrayList.lastIndexOf("zz"));
        //移除指定位置的元素，并返回他的值
        list.remove(0);
        System.out.println(arrayList);
        //替换
        arrayList.set(0,"漳卅");
        System.out.println(arrayList);
        //前闭后开 返回一个子集合
        List list1 = arrayList.subList(0, 2);
        System.out.println(list1);

    }
}

例二

package ListApp;

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

public class List003 {
    public static void main(String[] args) {
        List arrayList = new ArrayList();
        Book2 b1=new Book2("罗贯中","三国",20);
        Book2 b2=new Book2("吴承恩","西游记",10);
        Book2 b3=new Book2("施耐庵","水浒传",60);
        Book2 b4=new Book2("曹雪芹","红楼梦",5);
        arrayList.add(b1);
        arrayList.add(b2);
        arrayList.add(b3);
        arrayList.add(b4);
        for (Object o : arrayList) {
            System.out.println(o);
        }
        sss(arrayList);
        System.out.println("排序后");
        for (Object o : arrayList) {
            System.out.println(o);
        }
    }
    public static void sss(List list){
        //注意 size才是求集合长度的方法
        int num=list.size();
        for (int i = 0; i < num; i++) {
            for (int j = 0; j < num - 1 - i; j++) {
                //转换成book类型
                //向下转型 把父类对象 List转成子类的引用
                Book2 o1 =(Book2) list.get(j);
                Book2 o2 =(Book2) list.get(j + 1);
                if(o1.getPrice()>o2.getPrice()){
                    list.set(j,o2);
                    list.set(j+1,o1);
                }
            }
        }
    }
}
class Book2{
    private String name;
    private  String bookname;
    private double price;
    @Override
    public String toString() {
        return "书名:"+getBookname()+"\t\t"+"作者名:"+getName()+"\t\t"+"价格:"+price;
    }

    public Book2(String name, String bookname, double price) {
        this.name = name;
        this.bookname = bookname;
        this.price = price;
    }

    public double getPrice() {
        return price;
    }

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

    public String getName() {
        return name;
    }

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

    public String getBookname() {
        return bookname;
    }

    public void setBookname(String bookname) {
        this.bookname = bookname;
    }

    public Book2(String name, String bookname) {
        this.name = name;
        this.bookname = bookname;
    }
}

LinkedList集合

package ListApp;

import java.util.LinkedList;

public class LinkList001 {
    public static void main(String[] args) {
        Book002 book001 = new Book002("罗贯中","三国演义");
        Book002 book002 = new Book002("施耐庵","水浒传");
        Book002 book003 = new Book002("吴承恩","西游记");
        Book002 book004 = new Book002("曹雪芹","红楼梦");
        LinkedList linkedList = new LinkedList();
        linkedList.add(book001);
        //增加一个对象 输出
        System.out.println(linkedList);
        linkedList.add(book002);
        linkedList.add(book003);
        linkedList.add(book004);
        System.out.println(linkedList);
        //删除对象
        //3种方式.默认无参删除第一个，或者给一个明确的对象，或者给出索引
        linkedList.remove();
        linkedList.remove(book004);
        System.out.println(linkedList);
        //返回第一个对象
        System.out.println(linkedList.element());
    }
}
class Book002{
    private String author;
    private String bookname;

    public Book002(String author, String bookname) {
        this.author = author;
        this.bookname = bookname;
    }

    public String getAuthor() {
        return author;
    }

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

    public String getBookname() {
        return bookname;
    }

    public void setBookname(String bookname) {
        this.bookname = bookname;
    }

    @Override
    public String toString() {
        return "Book{" +
                "author='" + author + '\'' +
                ", bookname='" + bookname + '\'' +
                '}';
    }
}

hashSet集合

package ListApp;

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;

public class HashSet001 {
    public static void main(String[] args) {
        Book004 book001 = new Book004("张三",18);
        Book004 book002 = new Book004("张三2",22);
        Book004 book003 = new Book004("张三3",32);
        Book004 book004 = new Book004("张三",18);
        Set hashSet = new HashSet();
        hashSet.add(book001);
        hashSet.add(book002);
        hashSet.add(book003);
        hashSet.add(book004);
        //如果不重写hashCode方法，它先获取哈希值，如果哈希值不同就会添加，如果不同就添加
        //重写之后，会根据你的author和age来判断，如果有相同的，那么就不会在添加仅set集合里
        //所以我们输出一下，就得到了不重复的集合
        System.out.println(hashSet);
    }

}
class Book004{
    private String author;
    private int age;

    public Book004(String author, int age) {
        this.author = author;
        this.age = age;
    }

    public String getAuthor() {
        return author;
    }

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

    public int getage() {
        return age;
    }

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

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

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Book004 book004 = (Book004) o;
        return age == book004.age && Objects.equals(author, book004.author);
    }

    @Override
    public int hashCode() {
        return Objects.hash(author, age);
    }
}

hashCode及equals

package ListApp;

import java.util.HashSet;
import java.util.Objects;

public class HashSet002 {
    public static void main(String[] args) {
        Employee employee1 = new Employee("张三", "男", new MyDate(2000, 5, 15));
        Employee employee2 = new Employee("张三", "男", new MyDate(1998, 5, 15));
        Employee employee3 = new Employee("张三", "男", new MyDate(2000, 5, 15));
        Employee employee4 = new Employee("王二", "男", new MyDate(2000, 5, 15));
        HashSet hashSet = new HashSet();
        //我们来看看下面2种为什么是不同结果
        //答：在第一个种，如果我们只输出new MyDate(2000,5,15),并且不重写他的tostring方法，因为sout会默认调用tostring方法
        //我们就会发现，new MyDate(2000,5,15)和new MyDate(2000,5,15)是不一样的，因为他们的地址不同。
        System.out.println(new MyDate(2000,5,15).equals(new MyDate(2000,5,15)));
        //而下面这种情况，我们把他们全部转为了字符串，只要字符串一致，指向的地址就是一致的。
        //这是String里面讲到的性质，new2个一样的string是不同的，但是如果两个一样的字符串则是相同的。
        System.out.println((new MyDate(2000,5,15)).toString().equals((new MyDate(2000,5,15)).toString()));
        //下面就用到了上面的性质。

        //每一个set.add操作都会执行hashcode方法,返回一个编码，如果编码不同，那么就确定集合里没有这个对象，直接就加入集合中
        //如果一样，不能确定是否真的相同，就还要equal一下，比较一下各个字段是否相同。

        //那为了达到我们的要求，只要是不同年同月同日的看做是不同的人即使名字性别相同

        //我们必须继续改造hashcode方法
        //因为hashocpde在进行判断的时候，是把这个交给equals处理的
        //因此我们就把传入的birthday对象转为字符串，只要比较birthday是否相等，就能判断是不是同一个人
        //这里涉及到一个知识点
        //在对比字符串中的每个字段，
        hashSet.add(employee1);
        hashSet.add(employee2);
        hashSet.add(employee3);
        /*
        birthday都是:24052527
        最终的返回值都是:564264882
        是同一个
        */
        hashSet.add(employee4);
        System.out.println(hashSet);
        System.out.println("qwe".equals("qwe"));
    }

}

class Employee {
    private String name;
    private String sal;
    private MyDate birthday;

    @Override
    public String toString() {
        return "Employee{" +
                "姓名='" + name + '\'' +
                ", 性别='" + sal + '\'' +
                ", 生日=" + birthday +
                '}';
    }

    public Employee(String name, String sal, MyDate birthday) {
        this.name = name;
        this.sal = sal;
        this.birthday = birthday;
    }

    public String getName() {
        return name;
    }

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

    public String getSal() {
        return sal;
    }

    public void setSal(String sal) {
        this.sal = sal;
    }

    public MyDate getBirthday() {
        return birthday;
    }

    public void setBirthday(MyDate birthday) {
        this.birthday = birthday;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Employee employee = (Employee) o;

        return Objects.equals(name, employee.name) && Objects.equals(sal, employee.sal);
    }


    //hashcode方法的返回值是一个编码，是:根据传入的值返回一个编码
    @Override
    public int hashCode() {
        //在此打断点就可以看出
        //birthday都是:24052527
        //以及每个对象最终的返回值都是:564264882
        //整篇文章中最重要的4点
        //首先、把birthday转为字符串，不然返回的编码肯定不一样。
        //然后、根据传入的3个值返回一个编码。
        //其次、但是这个返回的值可能是一样的，可能是不同但是返回的编码是一样的，所以还要用euqal判断。
        //所以最后还要用到euqals判断对象其他具体的值是否一样，判断后如果不一样那必然不是同一个对象，如果一样就不重复添加了。
        return Objects.hash(name, sal, birthday.toString());
        //这里不能直接传birthday，因为它是一个对象，肯定是不同的
        //能直接传的都是变量。
    }
}

class MyDate {
    private int year;
    private int month;
    private int day;

    public MyDate() {
    }

    public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public int getYear() {
        return year;
    }


    public void setYear(int year) {
        this.year = year;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }

    @Override
    public String toString() {
        return "MyDate{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }
}

hashSet集合

package ListApp;

import java.util.*;

public class SetList {
    public static void main(String[] args) {
        Book003 book001 = new Book003("罗贯中", "三国演义");
        Book003 book002 = new Book003("施耐庵", "水浒传");
        Book003 book003 = new Book003("吴承恩", "西游记");
        Book003 book004 = new Book003("曹雪芹", "红楼梦");
        //Set有2个子类，一个hashset 一个 treeset
        //我们先用hashset
        //为了体现面向对象的思想，编译对象我们用Set,表明hashset是set的子类，并且实现了set接口
        Set hashSet = new HashSet();
        hashSet.add(book001);
        System.out.println("未添加重复元素前:" + hashSet);
        hashSet.add(book001);
        hashSet.add(book002);
        hashSet.add(book003);
        hashSet.add(book004);
        //输出的应该应该是不含重复的，因为传入的对象是相同的索引地址，哈希值一样，hashSet就会自动删去重复的
        System.out.println("第一种添加重复元素后:" + hashSet + "\t并且元素顺序和添加顺序不一样");
        //但是，当你new一个新的对象出来的时候，地址就变了，哈希值就变了，它依然会被添加进去
        hashSet.add(new Book003("罗贯中","西游记"));
        hashSet.add("aa");
        hashSet.add("aa");
        System.out.println("第二种添加重复元素后:" + hashSet + "\t并且元素顺序和添加顺序不一样");
        System.out.println("查看set种有多少个对象:" + hashSet.size() + "\t可以看出并没有添加上重复的元素");
        for (Object o : hashSet) {
            System.out.println("遍历:" + o);
        }
        System.out.println("遍历方式二:调用iterator方法，生成构造器对象");
        Iterator iterator = hashSet.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next);
        }
    }
    static class Book003 {
        private String author;
        private String bookname;

        public Book003(String author, String bookname) {
            this.author = author;
            this.bookname = bookname;
        }

        public String getAuthor() {
            return author;
        }

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

        public String getBookname() {
            return bookname;
        }

        public void setBookname(String bookname) {
            this.bookname = bookname;
        }

        @Override
        public String toString() {
            return "Book{" +
                    "author='" + author + '\'' +
                    ", bookname='" + bookname + '\'' +
                    '}';
        }
    }
}

补充：JAVA编译类型和运行类型
为什么要设立编译类型和运行类型呢？
1）如果你下面的方法要调用编译类型的方法，你就必须写编译类型，如果你下面要用到的方法，编译类型没有，在运行类型里面，那等号两边则是相同的类。
2）体现了JAVA面向对象的思想

hashMap

package ListApp.ListHomeWork;

import java.security.Key;
import java.util.HashMap;
import java.util.Set;

public class HomeWork002 {
    public static void main(String[] args) {
        master m1 = new master("张三", 25550);
        master m2 = new master("李四", 15050);
        master m3 = new master("王二小", 12550);
        HashMap hashMap = new HashMap();
        hashMap.put(m1.getName(), m1.getSalary() + "元");
        hashMap.put(m2.getName(), m2.getSalary() + "元");
        hashMap.put(m3.getName(), m3.getSalary() + "元");
        //张三工资改为35000
        hashMap.put(m1.getName(), 2600.0 + "元");
        System.out.println("没加工资前：");
        System.out.println(hashMap);
        //所有员工工资加100
        Set set = hashMap.keySet();
        for (Object o : set) {
            if (o.equals("张三")) {
                hashMap.put(o, m1.getSalary() + 100);
            } else if (o.equals("李四")) {
                hashMap.put(o, m2.getSalary() + 100);
            } else
            {
                hashMap.put(o, m3.getSalary() + 100);
            }
        }
        System.out.println(hashMap);
    }

}

class master {
    private String name;
    private double salary;

    @Override
    public String toString() {
        return "姓名：" + name + "\t工资:" + salary;
    }

    public String getName() {
        return name;
    }

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

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public master(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }
}

例二

package ListApp;

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

/**
 * @author TMJIE5200
 */
public class HashMap001 {
    public static void main(String[] args) {
        //hashmap的不允许重复，其实可以看做替换
        Map hashMap = new HashMap();
        hashMap.put("学生:","小明");//前面是key 后面是value
        hashMap.put("职工:","李老师");
        hashMap.put("学生:","小红");
        hashMap.put("老师:","小红");//不允许重复是指key不能重复
        hashMap.put("","小红");//key 能为空 但只能唯一一个 value可以无数个
        System.out.println(hashMap);
    }
}

HashMap entrySet() 方法

返回一个hashmap的集合。