1.LinkedList
- 面试题：
2.Object类
- 方法：
- 3.Set集合
  - 3.1HashSet
  - 3.2HashSet存对象

1.LinkedList

List是父类接口  Deque 队列
双向链表
队列：先进先出  排队
栈：先进后出   弹夹
特征：查询数据慢，增删改快

LinkedList方法

add(int a , E e);//指定位置添加数据
addFirst(E e);//添加数据在首位
addLast(E e);//添加数据在最后

package com.qfedu.test2LinkedList;
import java.util.Iterator;
import java.util.LinkedList;
//LinkedList 的使用和遍历
public class Demo1 {
    public static void main(String[] args) {
        LinkedList<String> list1 = new LinkedList<String>();
        //这个不能多态，子类独有的方法
        //因为LinkedList实现了List接口，但是LinkedList有自己独有的方法
        //就不要在父类的引用了
        list1.add("农夫山泉");
        list1.add("六个核桃");
        list1.add("康师傅");
        System.out.println(list1);
        list1.add(1, "雪碧");
        System.out.println(list1);
        list1.addFirst("可乐");
        System.out.println(list1);
        list1.addLast("a ?");
        System.out.println(list1);
        //遍历1：增强for
        for (String string : list1) {
            System.out.println(string);
        }
        System.out.println("--------------");
        //遍历2：for
        Object[] obj =list1.toArray();
        for (int i = 0; i < obj.length; i++) {
            System.out.println(list1.get(i));
        }
        System.out.println("--------------");
        //遍历3：迭代器
        Iterator<String> iterator = list1.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

面试题：

ArrayList和LinkedList的区别：

ArrayList：底层是数组，初始容量为10，超过10个数据以后会自动扩容，每次扩容是之前的1.5倍
 特征：
  增删慢：
    1.增加数据的时候可能涉及到数组的扩容，数组赋值，效率低
    2.增加一个数据或者删除一个数据，可能牵涉到数组的前移和后移，查询慢（for）
  查询快：
    1.底层用的索引，可以直接找到当前值，时间复杂度是1，比如：目录
    因为开发中查询偏多，所以使用ArrayList多
LinkedList底层是双线链表
    增删快：直接找到被增加或者被删除那个数据的前置节点对象和后置节点对象进行添加和删除。时间复杂度是1
    查询慢：因为底层是二分法查找的算法（二分法自己百度看）。时间复杂度是n/2 使用的for循环，凡是牵涉到for循环效率都低

2.Object类

Object是java所有类的超类，或者基类。是所有类的祖宗类

方法：

toString

String toString();变成字符串

package com.qfedu.test3Object;
//Object的toString方法
class Person{//Person继承了Object
    String name;
    int age;
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "a ?";
        person.age = 18;
        //打印的时候会自己执行toString方法
        System.out.println(person);
    }
}

equals

对象.equals（对象）：比较的是地址

”字符串“.equals（“字符串”）：比较的是内容

源码比较内存地址的，如下

public boolean equals (object boj){
    return (this == obj);
}

Object类下面的equals方法比较的是内存地址所有使用了==

为什么String类的equals方法比较的是内容？能相同吗？

String继承Object，重写了equals，在重写的equals方法中不仅判断了内存地址，还判断了String的内容，内存地址和内容都是true

Object类下的equals方法比较的是内存地址。

String类下的equals方法比较的是内存地址和内容，都为true才为true。

String类是java封装的

需求：比较两个对象内容是否一致

重写equals方法：

package com.qfedu.test3Object;
//Object的equals方法
class Student{
    int id;
    String name;
    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + "]";
    }
    @Override
    public boolean equals(Object obj) {//向上转型
        if(this == obj) {//内存地址一样 就直接返回true
            return true;
        }
        //如果对象的内容一样，也要返回true
        //将object类型的数据强转为Student类型的数据
        if (obj instanceof Student) {
            Student stu = (Student)obj;//向下转型
            //stu是student2的是属性值-->看代码39行
            //this是student的是属性值
            return stu.id == this.id && stu.name.equals(this.name);
        }
        return false;
    }
}
public class Demo2 {
    public static void main(String[] args) {
        Student student = new Student(1, "朱志伟");
        Student student2 = new Student(1, "朱志伟");
        //Student继承了Object，所以equals可以使用
        boolean b1 = student.equals(student2);
        //内容一样，内存地址不一样 所以false
        System.out.println(b1);//false-->重写之后就是true
    }
}

hashCode

返回一个int的数据，object类中的hashCode方法把内存地址16进制的转换为10进制

//hashCode方法
public class Demo3 {
    public static void main(String[] args) {
        Object object = new Object();
        Object object2 = new Object();
        //以上两个的内存地址不一样
        System.out.println(object);//java.lang.Object@15db9742
        int a = object.hashCode();
        System.out.println(a);//366712642
        System.out.println(object2.hashCode());//1829164700
    }

String类下对hashCode进行了重写！！！这个重写的hashCode不在返回的内存的地址，返回的是字符串的ASSCI码值

        String string = new String("aa");
        String string2 = new String("aa");
        System.out.println(string.hashCode());//3104--返回ASSCI码值，不是地址
        System.out.println(string2.hashCode());//3104

要求：

重写了equals的方法，必须也要重写hashCode方法

ASSCI码一样，对象不一样一定

package com.qfedu.test3Object;
//重写了equals的方法，必须也要重写hashCode方法
//官方手册要求
//如果根据equals(Object)方法两个对象相等，
//则在两个对象中的每个对象上调用hashCode方法必须产生相同的整数结果。
class Teacher{
    int id;
    String name;
    public Teacher(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj instanceof Teacher) {
            Teacher t = (Teacher)obj;
            return t.id == this.id && t.name.equals(this.name);
        }
        return super.equals(obj);
    }
    @Override
    public int hashCode() {
//        return id;
        return name.hashCode();//如果没有int类型，直接用字符串重写的hashCode方法
    }
    @Override
    public String toString() {
        return "Teacher [id=" + id + ", name=" + name + "]";
    }
}
public class Demo3test {
    public static void main(String[] args) {
        Teacher teacher = new Teacher(1, "朱志伟");
        Teacher teacher1 = new Teacher(1, "朱志伟");
        System.out.println(teacher.equals(teacher1));
        //如果根据equals(Object)方法两个对象相等，
        //则在两个对象中的每个对象上调用hashCode方法必须产生相同的整数结果。
        //借助id，只比较id就行了
        System.out.println(teacher.hashCode());
        System.out.println(teacher1.hashCode());
    }
}

3.Set集合

Set集合也是一个接口，和List一样

可以存数据，无序的，不可重复的。开发中少用

Set接口下面的两个实现类

  HashSet：底层是根据哈希值进行存储的，如果hash值一样，就存不了数据了
  TreeSet：底层是一个二叉树，对存入的数据可以进行自然排序

3.1HashSet

对集合的迭代次序不做任何保证（无序），特别是它不能保证数据在一段时间内保持不变，可以添加null值

HashSet的方法：
    add(E e);
    remove(E e);

3.2HashSet存对象

package com.qfedu.test4hashSet;
//练习
import java.util.HashSet;
import java.util.Set;
class Employee{
    private String name;
    private int age;
    public Employee(String name, int age) {
        super();
        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 boolean equals(Object obj) {
        if(this == obj) {
            return true;
        }
        if (obj instanceof Employee) {
            Employee e = (Employee)obj;
            return e.getName().equals(this.getName()) && e.getAge() == this.getAge();
        }
        return false;
    }
    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return age;
    }
    @Override
    public String toString() {
        return "Employee [name=" + name + ", age=" + age + "]";
    }
}
public class Demo2test {
    public static void main(String[] args) {
        Employee employee1 = new Employee("朱志伟", 24);
        Employee employee2 = new Employee("朱志伟", 24);
        Employee employee3 = new Employee("杨博", 23);
        Set<Employee> set = new HashSet<Employee>();
        set.add(employee1);
        set.add(employee2);
        set.add(employee3);
        System.out.println(set);
    }
}

zhuzhiwei

401LinkedList、toString、euqals、hashCode、Set集合、HashSet