java学习笔记6

2018-11-06 本文已影响0人海洋_5ad4

迭代器的原理及源码解析

A:迭代器原理
- 迭代器原理:迭代器是对集合进行遍历,而每一个集合内部的存储结构都是不同的,所以每一个集合存和取都是不一样,那么就需要在每一个类中定义hasNext()和next()方法,这样做是可以的,但是会让整个集合体系过于臃肿,迭代器是将这样的方法向上抽取出接口,然后在每个类的内部,定义自己迭代方式,这样做的好处有二,第一规定了整个集合体系的遍历方式都是hasNext()和next()方法,第二,代码有底层内部实现,使用者不用管怎么实现的,会用即可
B:迭代器源码解析
- 1,在eclipse中ctrl + shift + t找到ArrayList类
- 2,ctrl+o查找iterator()方法
- 3,查看返回值类型是new Itr(),说明Itr这个类实现Iterator接口
- 4,查找Itr这个内部类,发现重写了Iterator中的所有抽象方法

List集合的特有功能概述和测试

A:List集合的特有功能概述
- void add(int index,E element)
- E remove(int index)
- E get(int index)
- E set(int index,E element)

package com.heima.list;

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

public class Demo1_List {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.set(1,"z");
        System.out.println(list);
    }

    public static void demo4() {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        //通过索引遍历List集合
        for(int i = 0;i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }

    public static void demo3() {
        List list = new ArrayList();
        list.add(111);
        list.add(222);
        list.add(333);
        
        list.remove(111);           //删除的时候不会自动装箱，把111当作索引
        System.out.println(list);
    }

    public static void demo2() {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        
        Object obj = list.remove(1);        //通过索引删除元素，将被删除的元素返回
        System.out.println(obj);
        System.out.println(list);
    }

    public static void demo1() {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add(4,"e");    //index<=size并且>=0都不会报异常
        //list.add(10,"z"); //java.lang.IndexOutOfBoundsException,
        System.out.println(list);//当存储时使用不存在的索引时，就会出现索引越界异常
    }

}

List集合存储学生对象并遍历

package com.heima.list;

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

import com.heima.bean.Student;

public class Demo2_List {

    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(new Student("张三",23));
        list.add(new Student("李四",24));
        list.add(new Student("王五",25));
        list.add(new Student("赵六",26));
        
        for (int i = 0; i < list.size(); i++) {
            //System.out.println(list.get(i));
            Student s = (Student)list.get(i);
            System.out.println(s.getName());
        }
    }

}

并发修改异常产生的原因及解决方案

A:案例演示
- 需求：我有一个集合，请问，我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现。
B:ConcurrentModificationException出现
- 迭代器遍历，集合修改集合
C:解决方案
- a:迭代器迭代元素，迭代器修改元素(ListIterator的特有功能add)
- b:集合遍历元素，集合修改元素

ListIterator

boolean hasNext()是否有下一个
boolean hasPrevious()是否有前一个
Object next()返回下一个元素
Object previous();返回上一个元素

package com.heima.list;

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

public class Demo4_ListIterator {

    /**
     * @param args
     */
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("a");                                  //Object obj = new String();
        list.add("b");
        list.add("world");
        list.add("c");
        list.add("d");
        list.add("e");
        
        ListIterator lit = list.listIterator();         //获取迭代器
        while(lit.hasNext()) {
            System.out.println(lit.next());             //获取元素并将指针向后移动
        }
        
        System.out.println("-----------------");
        
        while(lit.hasPrevious()) {
            System.out.println(lit.previous());         //获取元素并将指针向前移动
        }
    }

}

Vector的特有功能

A:Vector类概述
B:Vector类特有功能
- public void addElement(E obj)
- public E elementAt(int index)
- public Enumeration elements()

package com.heima.list;

import java.util.Enumeration;
import java.util.Vector;

public class Demo5_Vector {

    public static void main(String[] args) {
        Vector v = new Vector();
        v.addElement("a");
        v.addElement("b");
        v.addElement("c");
        v.addElement("d");
        
        Enumeration en = v.elements();              //获取枚举
        while(en.hasMoreElements()) {               //判断集合中是否有元素
            System.out.println(en.nextElement());   //获取集合中的元素
        }
    }

}

数据结构之数组和链表

A:数组
- 查询快修改也快
- 增删慢
B:链表
- 查询慢,修改也慢
- 增删快
  
  数组.jpg
  链表.jpg

List的三个子类的特点

A:List的三个子类的特点

  ArrayList:
      底层数据结构是数组，查询快，增删慢。
      线程不安全，效率高。

  Vector:
      底层数据结构是数组，查询快，增删慢。
      线程安全，效率低。
  Vector相对ArrayList查询慢(线程安全的)
  Vector相对LinkedList增删慢(数组结构)

  LinkedList:
      底层数据结构是链表，查询慢，增删快。
      线程不安全，效率高。

  Vector和ArrayList的区别
      Vector是线程安全的,效率低
      ArrayList是线程不安全的,效率高
  共同点:都是数组实现的

  ArrayList和LinkedList的区别
      ArrayList底层是数组结果,查询和修改快
      LinkedList底层是链表结构的,增和删比较快,查询和修改比较慢
  共同点:都是线程不安全的

B:List有三个儿子，我们到底使用谁呢?
查询多用ArrayList
增删多用LinkedList
如果都多ArrayList

去除ArrayList中重复字符串元素方式

package com.heima.list;

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

public class Demo1_Arraylist {

    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("a");
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("c");
        list.add("c");
        ArrayList newList = getSingle(list);
        System.out.println(newList);
    }
    
    public static ArrayList getSingle(ArrayList list) {
        ArrayList newList = new ArrayList();                //1,创建新集合
        Iterator it = list.iterator();          //2,根据传入的集合（老集合）获取迭代器
        while(it.hasNext()) {                   //3,遍历老集合
            Object obj = it.next();             //记录住每一个元素
            if(!newList.contains(obj)) {    //如果新集合中不包含老集合的元素，则将该元素添加
                newList.add(obj);
            }
        }
        return newList;
    }

}

去除ArrayList中重复自定义对象元素

package com.heima.list;

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

import com.heima.bean.Person;

public class Demo2_ArrayList {

    /**
     * @param args
     */
    public static void main(String[] args) {
        ArrayList list = new ArrayList();               //创建集合对象
        list.add(new Person("张三", 23));
        list.add(new Person("张三", 23));
        list.add(new Person("李四", 24));
        list.add(new Person("王麻子", 25));
        
        //ArrayList newList = getSingle(list);
        //System.out.println(newList);
        list.remove(new Person("张三", 23));  //一次只能删除一个new Person("张三", 23)
        System.out.println(list);
    }
    
    public static ArrayList getSingle(ArrayList list) {
        ArrayList newList = new ArrayList();                //1,创建新集合
        Iterator it = list.iterator();          //2,根据传入的集合（老集合）获取迭代器
        while(it.hasNext()) {                   //3,遍历老集合
            Object obj = it.next();             //记录住每一个元素
            if(!newList.contains(obj)) {    //如果新集合中不包含老集合的元素，则将该元素添加
                newList.add(obj);           //contains和remove底层依赖的是equals方法
            }
        }
        return newList;
    }
}

LinkedList的特有功能

A:LinkedList类概述

B:LinkedList类特有功能
- public void addFirst(E e)及addLast(E e)
- public E getFirst()及getLast()
- public E removeFirst()及public E removeLast()
- public E get(int index);

package com.heima.list;

import java.util.LinkedList;

public class Demo3_LinkedList {

    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.addFirst("a");
        list.addFirst("b");
        list.addFirst("c");
        list.addLast("d");
        
        //System.out.println(list.getFirst());  //c 
        //System.out.println(list.getLast());       //d
        
        //System.out.println(list.removeFirst());   //c
        //System.out.println(list.removeLast());    //d
        
        System.out.println(list.get(1));            //b 
        System.out.println(list);
    }

}

栈和队列数据结构

栈
- 先进后出
队列
- 先进先出

用LinkedList模拟栈数据结构的集合并测试

package com.heima.list;

import java.util.LinkedList;

public class Demo4_LinkedList {

    public static void main(String[] args) {
        Stack s = new Stack();
        s.in("a");  //进栈
        s.in("b");
        s.in("c");
        s.in("d");
        
        while(!s.isEmpty()) {   //判断栈是否为空
            System.out.println(s.out());    //弹栈
        }
    }

    public static void demo1() {
        LinkedList list = new LinkedList();         //创建集合对象
        list.addLast("a");
        list.addLast("b");
        list.addLast("c");
        list.addLast("d");
        while(!list.isEmpty()) {
            System.out.println(list.removeLast());
        }
    }

}

package com.heima.list;

import java.util.LinkedList;

public class Stack {
    private LinkedList list = new LinkedList();
    //模拟进栈方法
    public void in(Object obj) {
        list.addLast(obj);
    }
    //模拟出栈
    public Object out() {
        return list.removeLast();
    }
    //模拟栈结构是否为空
    public boolean isEmpty() {
        return list.isEmpty();
    }
}

泛型概述和基本使用

A:泛型概述
B:泛型好处
- 提高安全性(将运行期的错误转换到编译期)
- 省去强转的麻烦
C:泛型基本使用
- <>中放的必须是引用数据类型
D:泛型使用注意事项
- 前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型)

package com.heima.generic;

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

import com.heima.bean.Person;

public class Demo1_Generic {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //int[] arr = new byte[5];  //数组要保证前后的数据类型一致
        //ArrayList<Object> list = new ArrayList<Person>(); //集合的泛型要保证前后的数据类型一致 
        //ArrayList<Object> list = new ArrayList<>();   //1.7版本的新特性，菱形泛型
        ArrayList<Object> list = new ArrayList<>();
        //泛型最好不要定位成Object，因为任何类都是Object类的子类，所以和不加<>是一样的效果
        list.add("aaa");
        list.add(true);
    }

    public static void demo1() {
        ArrayList<Person> list = new ArrayList<Person>();
        //list.add(110);
        //list.add(true);
        list.add(new Person("张三",23));
        list.add(new Person("李四",24));
        
        Iterator<Person> it = list.iterator();
        while(it.hasNext()) {
            System.out.println(it.next().getName());//next方法会将指针向后移动
            //调用next方法多次，会将指针向后移动多次
        }
    }

}

ArrayList存储字符串和自定义对象并遍历泛型版

package com.heima.generic;

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

import com.heima.bean.Person;

public class Demo2_Generic {

    public static void main(String[] args) {
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("张三",23));
        list.add(new Person("李四",24));
        list.add(new Person("王五",25));
        list.add(new Person("赵六",26));
        
        Iterator<Person> it = list.iterator();
        while(it.hasNext()) {
            Person p = it.next();       //将集合中的每一个元素用Person记录
            System.out.println(p);
        }
    }

    public static void demo1() {
        ArrayList<String> list = new ArrayList<>(); //创建集合对象
        list.add("a");list.add("b");list.add("c");list.add("d");
        
        Iterator<String> it = list.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
    }

}

泛型的由来

A:案例演示
- 泛型的由来:通过Object转型问题引入
- 早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题。

泛型类的概述及使用

A:泛型类概述<T>
* 把泛型定义在类上

B:定义格式
- public class 类名<泛型类型1,…>
C:注意事项
- 泛型类型必须是引用类型
D:案例演示
- 泛型类的使用

泛型方法的概述和使用

A:泛型方法概述
- 把泛型定义在方法上
B:定义格式
- public <泛型类型> 返回类型方法名(泛型类型变量名)
C:案例演示
- 泛型方法的使用

package com.heima.bean;

public class Tool<Q> {
    private Q q;
    
    /*public void show(Q q) {   //方法泛型最好与类的泛型一致
        System.out.println(q);
    }*/
    
    public<T> void show(T t) {  //如果不一致，需要在方法上声明该泛型
        System.out.println(t);
    }
    public static<W> void print(W w) {  //静态方法必须声明自己的泛型
        System.out.println(w);  //因为类的泛型是类实例化的时候（生成对象的时候）传入的，静态方法是随着类的加载而加载，矛盾。
    }
}

泛型接口的概述和使用

A:泛型接口概述
- 把泛型定义在接口上
B:定义格式
- public interface 接口名<泛型类型>
C:案例演示
- 泛型接口的使用

package com.heima.generic;

public class Demo4_Generic {

    public static void main(String[] args) {

    }

}

interface Inter<T> {
    public void show(T t);
}

/*class Demo implements Inter<String> {     //推荐用这种

    @Override
    public void show(String t) {
        System.out.println(t);
    }
    
}*/         //第一种方式

class Demo<T> implements Inter<T> {         //没有必须在实现接口的时候给自己类加泛型

    @Override
    public void show(T t) {
        System.out.println(t);
    }
    
}

泛型高级之通配符

A:泛型通配符<?>
- 任意类型，如果没有明确，那么就是Object以及任意的Java类了
B:? extends E
- 向下限定，E及其子类
C:? super E
- 向上限定，E及其父类

package com.heima.generic;

import java.util.ArrayList;

import com.heima.bean.Person;

public class Demo5_Generic {

    public static void main(String[] args) {
        //List<?> list = new ArrayList<Integer>();//当右边的泛型时不确定时，左边也可以指定为？       
        ArrayList<Person> list1 = new ArrayList<>();
        list1.add(new Person("张三",23));
        list1.add(new Person("李四",24));
        list1.add(new Person("王五",25));
        
        ArrayList<Person> list2 = new ArrayList<>();
        list2.add(new Person("赵六",26));
        list2.add(new Person("周七",27));
        
        list1.addAll(list2);        //list2必须是list1的子类，子类提升为父类
        System.out.println(list1);
    }

}

增强for的概述和使用

A:增强for概述
- 简化数组和Collection集合的遍历
B:格式：
for(元素数据类型变量 : 数组或者Collection集合) {
使用变量即可，该变量就是元素
}
C:案例演示
- 数组，集合存储元素用增强for遍历
D:好处
- 简化遍历

package com.heima.jdk5;

import java.util.ArrayList;

import com.heima.bean.Person;
//增强for循环底层依赖的是迭代器(Iterator)
public class Demo1_Foreach {

    public static void main(String[] args) {
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("张三", 23));
        list.add(new Person("李四", 24));
        list.add(new Person("王五", 25));
        list.add(new Person("赵六", 26));
        for (Person person : list) {
            System.out.println(person);
        }
    }

    public static void demo1() {
        int[] arr = {11,22,33,44,55};
        for (int i : arr) {
            System.out.println(i);
        }
        
        ArrayList<String> list = new ArrayList<>();
        list.add("a");list.add("b");list.add("c");
        for (String string : list) {
            System.out.println(string);
        }
    }

}

三种迭代的能否删除

普通for循环,可以删除,但是索引要--
迭代器,可以删除,但是必须使用迭代器自身的remove方法,否则会出现并发修改异常
增强for循环不能删除

package com.heima.jdk5;

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

import com.heima.bean.Person;
//增强for循环底层依赖的是迭代器(Iterator)
public class Demo1_Foreach {

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("a");
        list.add("d");
        list.add("b");
        list.add("b");
        //1,普通for循环删除
        /*for(int i = 0;i < list.size(); i++) {
            if("b".equals(list.get(i))) {
                list.remove(i--);   //删除的时候后面的所有元素都向前移一位，所以索引要--
                //就算b出现在第一位也不会报错，因为执行i--后会执行i++。
            }
        }*/
        //2,迭代器删除
        /*for(Iterator<String> it2 = list.iterator(); it2.hasNext();) {
            if("b".equals(it2.next())) {
                it2.remove();
            }
        }*/
        /*Iterator<String> it = list.iterator();
        while(it.hasNext()) {
            if("b".equals(it.next())) {
                //list.remove("b"); //不能用集合的删除方法，因为迭代过程中如果集合修改会出现并发修改异常
                it.remove();
            }
        }*/
        //3,增强for循环不能删除，只能遍历。因为增强for循环的底层是通过迭代器实现的，调用集合的remove方法会引发并发修改异常
        for (String string : list) {
            if("b".equals(string)) {
                list.remove("b");
            }
        }
        System.out.println(list);
    }
    
    
    public static void demo2() {
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("张三", 23));
        list.add(new Person("李四", 24));
        list.add(new Person("王五", 25));
        list.add(new Person("赵六", 26));
        for (Person person : list) {
            System.out.println(person);
        }
    }

    public static void demo1() {
        int[] arr = {11,22,33,44,55};
        for (int i : arr) {
            System.out.println(i);
        }
        
        ArrayList<String> list = new ArrayList<>();
        list.add("a");list.add("b");list.add("c");
        for (String string : list) {
            System.out.println(string);
        }
    }

}

静态导入的概述和使用

A:静态导入概述
B:格式：
- import static 包名….类名.方法名;
- 可以直接导入到方法的级别
C:注意事项
- 方法必须是静态的,如果有多个同名的静态方法，容易不知道使用谁?
  这个时候要使用，必须加前缀。由此可见，意义不大，所以一般不用，但是要能看懂。

package com.heima.jdk5;

import static java.util.Arrays.sort;        //静态导入
import static java.util.Arrays.toString;

public class Demo2_StaticImport {
    //静态导入开发不用，但是需要能看懂
    public static void main(String[] args) {
        int[] arr = {55,22,33,44,11};
        //Arrays.sort(arr);             //排序
        sort(arr);
        //System.out.println(Arrays.toString(arr));
        //System.out.println(toString(arr));        //toString方法静态导入不能用
        System.out.println(arr);
    }

}

可变参数的概述和使用

A:可变参数概述
- 定义方法的时候不知道该定义多少个参数
B:格式
- 修饰符返回值类型方法名(数据类型… 变量名){}
C:注意事项：
- 这里的变量其实是一个数组
- 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

package com.heima.jdk5;

public class Demo3_ChangeableArgs {

    /**
     * @param args
     */
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55};
        //print(arr);
        print(11,22,33,44,55);      //只支持可变参数的形式
        //print();
    }
    
    /*public static void print(int[] arr) {
        for(int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }*/
    
    public static void print(int x,int ... arr) {           //可变参数其实是一个数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

}

Arrays工具类的asList()方法的使用

A:案例演示
- Arrays工具类的asList()方法的使用
- Collection中toArray(T[] a)泛型版的集合转数组

package com.heima.jdk5;

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

public class Demo4_AsList {

    /**
     * 数组转换成集合虽然不能增加或减少元素，但是可以用集合的思想操作数组，也就是说可以使用其他集合中的方法
     */
    public static void main(String[] args) {
        //集合转数组，加泛型的
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        
        String[] arr = list.toArray(new String[10]);    
        for (String string : arr) {     //当集合转换数组时，数组长度如果是小于等于集合的size时，转换后的数组长度等于集合的size
            System.out.println(string); //如果数组的长度大于了size，分配的数组长度就和你指定的长度一样，自动补上null
        }
    }

    public static void demo2() {
        /*int[] arr = {11,22,33,44,55};
        List<int[]> list = Arrays.asList(arr);  //将整个数组放在集合里面，泛型是int型数组
        System.out.println(list);   //基本数据类型的数组转换成集合，会将整个数组当作一个对象转换
*/  
        Integer[] arr = {11,22,33,44,55};   //将数组转换成集合，数组必须是引用数据类型
        List<Integer> list = Arrays.asList(arr);
        System.out.println(list);
    }

    public static void demo1() {
        String[] arr = {"a","b","c"};
        List<String> list = Arrays.asList(arr);     //数组转换成集合
        //list.add("d");    //UnsupportedOperationException，不能添加
        System.out.println(list);
    }

}

集合嵌套之ArrayList嵌套ArrayList

package com.heima.list;

import java.util.ArrayList;

import com.heima.bean.Person;

public class Demo5_ArrayListArrayList {

    public static void main(String[] args) {
        ArrayList<ArrayList<Person>> list = new ArrayList<>();
        
        ArrayList<Person> first = new ArrayList<>();    //创建第一个班级
        first.add(new Person("杨幂",30));
        first.add(new Person("李冰冰",33));
        first.add(new Person("范冰冰",20));
        
        ArrayList<Person> second = new ArrayList<>();
        second.add(new Person("黄晓明",31));
        second.add(new Person("赵薇",33));
        second.add(new Person("陈坤",32));
        
        //将班级添加到学科集合中
        list.add(first);
        list.add(second);
        
        //遍历学科集合
        for (ArrayList<Person> a : list) {
            for (Person p : a) {
                System.out.println(p);
            }
        }
    }

}

HashSet储存字符串并遍历

package com.heima.set;

import java.util.HashSet;

public class Demo1_HashSet {

    /**
     * Set集合，无索引，不可以重复，无序(存取不一致)
     */
    public static void main(String[] args) {
        HashSet<String> hs = new HashSet<>();   //创建HashSet对象
        boolean b1 = hs.add("a");
        boolean b2 = hs.add("a");   //当向set集合中储存重复元素的时候返回为false
        hs.add("b");
        hs.add("c");
        hs.add("d");
        System.out.println(hs);     //HashSet的继承体系中有重写toString方法
        System.out.println(b1);
        System.out.println(b2);
        
        for (String string : hs) {  //只要能用迭代器迭代的，就可以使用增强for循环遍历
            System.out.println(string);
        }
    }

}

HashSet如何保证元素唯一性的原理

1.HashSet原理
- 我们使用set集合都是需要去掉重复元素的，如果在存储的时候逐个equals比较，效率较低，哈希算法提高了去重复的效率，降低了使用equals()方法的次数
- 当HashSet调用add()方法存储对象的时候，先调用对象的hashCode()方法得到一个哈希值，然后再集合中查找是否有哈希值相同的对象
  - 如果没有哈希值相同的对象就直接存入集合
  - 如果有哈希值相同的对象，就和哈希值相同的对象逐个进行equals比较，比较结果为false就存入，true则不存
2.将自定义类的对象存入HashSet去重复
- 类中必须重写hashCode()和equals()方法
- hashCode()：属性相同的对象返回值必须相同，属性不同的返回值尽量不同（提高效率）
- equals()：属性相同返回true，属性不同返回false，返回false的时候储存

package com.heima.bean;

public class Person {
    private String name;
    private int age;    
    public Person() {
        super();
        
    }
    public Person(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 String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    /*@Override
    public boolean equals(Object obj) {
        System.out.println("执行了吗");
        Person p = (Person)obj;
        return this.name.equals(p.name) && this.age == p.age;
    }
    @Override
    public int hashCode() {
        final int NUM = 38;
        return name.hashCode() * NUM + age;
    }*/
    /*
     * 为什么是31？
     * 1，31是一个质数，质数是能被1和自己本身整除的数
     * 2，31这个数既不大也不小
     * 3，31这个数好算，2的五次方-1，2向左移动5位减一
     */
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)    //调用的对象和传入的对象是同一个对象
            return true;    //直接返回true
        if (obj == null)    //传入的对象为null
            return false;   //返回false
        if (getClass() != obj.getClass())   //判断两个对象对应的字节码文件是否是同一个字节码
            return false;                   //如果不是直接返回false
        Person other = (Person) obj;        //向下转型
        if (age != other.age)               //调用对象的年龄不等于传入对象的年龄
            return false;                   //返回false
        if (name == null) {                 //调用对象的姓名为null
            if (other.name != null)         //传入对象的姓名不为null
                return false;               //返回false
        } else if (!name.equals(other.name))//调用对象的姓名不为null，且不等于传入对象的姓名
            return false;                   //返回false
        return true;                        //返回true
    }
    
    
}

package com.heima.set;

import java.util.HashSet;

import com.heima.bean.Person;

public class Demo1_HashSet {

    /**
     * Set集合，无索引，不可以重复，无序(存取不一致)
     */
    public static void main(String[] args) {
        HashSet<Person> hs = new HashSet<>();
        hs.add(new Person("张三", 23));
        hs.add(new Person("张三", 23));
        hs.add(new Person("李四", 24));
        hs.add(new Person("李四", 24));
        hs.add(new Person("李四", 24));
        hs.add(new Person("李四", 24));
        
        System.out.println(hs);
    }

    public static void demo1() {
        HashSet<String> hs = new HashSet<>();   //创建HashSet对象
        boolean b1 = hs.add("a");
        boolean b2 = hs.add("a");   //当向set集合中储存重复元素的时候返回为false
        hs.add("b");
        hs.add("c");
        hs.add("d");
        System.out.println(hs);     //HashSet的继承体系中有重写toString方法
        System.out.println(b1);
        System.out.println(b2);
        
        for (String string : hs) {  //只要能用迭代器迭代的，就可以使用增强for循环遍历
            System.out.println(string);
        }
    }

}

LinkedHashSet的使用

package com.heima.set;

import java.util.LinkedHashSet;

public class Demo2_LinkedHashSet {

    /**
     * LinkedHashSet
     * 底层是链表实现的，是set集合中唯一一个能保证怎么存就怎么取的集合对象
     * 因为是HashSet的子类，所以也是保证元素唯一的，与HashSet的原理一样
     */
    public static void main(String[] args) {
        LinkedHashSet<String> lhs = new LinkedHashSet<>();
        lhs.add("a");
        lhs.add("a");
        lhs.add("b");
        lhs.add("c");
        lhs.add("a");
        lhs.add("b");
        lhs.add("c");
        System.out.println(lhs);
    }

}

练习

package com.heima.test;

import java.util.HashSet;
import java.util.Random;

public class Test1 {

    /**
     * 需求：编写一个程序，获取10个1至20的随机数，要求随机数不能重复。并把最终的随机数输出到控制台
     * 1，有Random类创建随机数对象
     * 2，需要存储10个随机数，而且不能重复，所以我们用HashSet集合
     * 3，如果HashSet的size是小于10就可以不断的存储，如果大于等于10就停止存储
     * 4，通过Random类中的nextInt(n)方法获取1到20之间的随机数，并将这些随机数存储在HashSet集合中
     * 5，遍历HashSet
     */
    public static void main(String[] args) {
        //1，有Random类创建随机数对象
        Random r = new Random();
        //2，需要存储10个随机数，而且不能重复，所以我们用HashSet集合
        HashSet<Integer> hs = new HashSet<>();
        //3，如果HashSet的size是小于10就可以不断的存储，如果大于等于10就停止存储
        while(hs.size() < 10) {
            //4，通过Random类中的nextInt(n)方法获取1到20之间的随机数，并将这些随机数存储在HashSet集合中
            hs.add(r.nextInt(20) + 1);
        }
        //5，遍历HashSet
        for (Integer integer : hs) {
            System.out.println(integer);
        }
    }

}

package com.heima.test;

import java.util.HashSet;
import java.util.Scanner;

public class Test2 {

    /**
     * 使用Scanner从键盘读取一行输入，去掉其中重复字符，打印出不同的那些字符
     * aaaabbbcccddd
     * 分析：
     * 1，创建Scanner对象
     * 2，创建HashSet对象，将字符存储，去掉重复
     * 3，将字符串转换为字符数组，获取每一个字符存储在HashSet集合中，自动去除重复
     * 4，遍历HashSet，打印每一个字符
     */
    public static void main(String[] args) {
        //1，创建Scanner对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一行字符串：");
        //2,创建HashSet对象，将字符存储，去掉重复
        HashSet<Character> hs = new HashSet<>();
        //3，将字符串转换为字符数组，获取每一个字符存储在HashSet集合中，自动去除重复
        String line = sc.nextLine();
        char[] arr = line.toCharArray();
        
        for (char c : arr) {        //char可以换成Character，自动装箱
            hs.add(c);
        }
        //4，遍历HashSet，打印每一个字符
        for(Character ch : hs) {    //Character可以换成char，自动拆箱
            System.out.print(ch);
        }
    }

}

package com.heima.test;

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

public class Test3 {

    /**
     * 需求：将集合中的重复元素去掉
     * 分析：
     * 1，创建List集合存储若干个重复元素
     * 2，单独定义方法去除重复
     * 3，打印一下List集合
     */
    public static void main(String[] args) {
        //1，创建List集合存储若干个重复元素
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("c");
        list.add("d");
        list.add("d");
        //2，单独定义方法去除重复
        getSingle(list);
        
        //3，打印一下List集合
        System.out.println(list);
    }
    /*
     * 去除List集合中的重复元素
     * 1，创建一个LinkedHashSet集合
     * 2，将List集合中所有的元素添加到LinkedHashSet集合
     * 3，将List集合中的元素清除
     * 4，将LinkedHashSet集合中的元素添加回List集合中
     */
    private static void getSingle(List<String> list) {
        //1，创建一个LinkedHashSet集合
        LinkedHashSet<String> lhs = new LinkedHashSet<>();
        //2，将List集合中所有的元素添加到LinkedHashSet集合
        lhs.addAll(list);
        //3，将List集合中的元素清除
        list.clear();
        //4，将LinkedHashSet集合中的元素添加回List集合中
        list.addAll(lhs);
    }

}

java学习笔记6

迭代器的原理及源码解析

List集合的特有功能概述和测试

List集合存储学生对象并遍历

并发修改异常产生的原因及解决方案

ListIterator

Vector的特有功能

数据结构之数组和链表

List的三个子类的特点

去除ArrayList中重复字符串元素方式

去除ArrayList中重复自定义对象元素

LinkedList的特有功能

栈和队列数据结构

用LinkedList模拟栈数据结构的集合并测试

泛型概述和基本使用

ArrayList存储字符串和自定义对象并遍历泛型版

泛型的由来

泛型类的概述及使用

泛型方法的概述和使用

泛型接口的概述和使用

泛型高级之通配符

增强for的概述和使用

三种迭代的能否删除

静态导入的概述和使用

可变参数的概述和使用

Arrays工具类的asList()方法的使用

集合嵌套之ArrayList嵌套ArrayList

HashSet储存字符串并遍历

HashSet如何保证元素唯一性的原理

LinkedHashSet的使用

练习

猜你喜欢

热点阅读