您现在的位置是:网站首页>javajava

ArrayList原理和 HashMap原理

deling2019年5月15日java287人已围观

简介ArrayList原理和 HashMap原理

ArrayList原理和 HashMap原理

泛型的介绍:在Collection接口中,泛型就是父类的泛型一般都是数据类型的一个占位符(形参),当对象实例化的时候,我们必须传入实际数据类型

在Collection接口中有两个子接口:Set和List接口
  • List接口:又叫List容器,List接口常用的实现类有三个: ArrayList、LinkedList、Vector,一般都用ArrayList

  • List接口是有序的,可以重复的

  • Set接口:又叫Set容器,Set接口常用的两个实现类 : HashSet、和TreeSet,一般用HashSet

  • Set是不可重复的,无序的

LinkedList

LinkedList实现了List接口,查询效率慢,线程不安全,增删效率快
LinkedList 是双向链表数组

LinkedList 继承自 AbstractSequenceList类,实现List接口

Vetor

Vetor:继承AbstractList类,实现Lis接口,线程安全,但是效率低

如何选用ArrayList、LinkedList、Vector?

1. 需要线程安全时,用Vector。  
2. 不存在线程安全问题时,并且查找较多用ArrayList(一般使用它)。 
3. 不存在线程安全问题时,增加或删除元素较多用LinkedList。

ArrayList介绍

ArrayList,继承了AbstractList类,实现了List接口

ArrayList是

import java.util.List下的类,别和import java.awt.List类搞混了

ArrayList底层是由数组实现的,查询速度快,线程不安全,增删效率低

ArrayList可以理解为动态数组:

ArrayList底层使用Object数组来存储元素数据。所有的方法,都围绕这个核心的Object数组来开展。

ArrayList中的Object类数组默认长度为10,当我们的数据超过10,则会创建定义一个新的长度更大的数组,然后将旧的数组中的数据复制到新的数组中,( System.arraycopy()方法),然后把新的引用赋值给旧的引用,(记得重写toString方法)

ArrayList中常用的方法

例如:

import java.util.ArrayList;
import java.util.Collection;
spublic class CollectionDemo {    
    public static void main(String[] args) {
        Collection<String> collection = new ArrayList<String>();        
        // add方法
        ((ArrayList<String>) collection).add("python");
        ((ArrayList<String>) collection).add("java");
        ((ArrayList<String>) collection).add("springboot");        
        // 打印输出容器中的内容,因为Collection中已经重写了 toString方法,所以打印的是重写toString后的内容,而不是内存地址
        System.out.println(collection);        
        // 判断接口中是否为空,返回类型是布尔值
        System.out.println(collection.isEmpty());
        System.out.println(collection.isEmpty());        
        // 输出容器中的大小
        System.out.println(collection.size());        
        // contains方法,判断容器中有没有这个元素,返回值为布尔类型
        System.out.println(collection.contains("java"));        
        // remove方法移除掉容器中的元素,但是只会移除内存地址指向的哪个引用名字,而不会移除这个对象,返回布尔类型
        System.out.println(collection.remove("python"));        
        // clear方法,用来清除掉容器中所有的元素
        collection.clear();
        System.out.println(collection);
    }

}
两个List接口之间的元素处理

例如:

import java.util.ArrayList;
import java.util.Collection;
    public class EnumDemo<E> {    
    public static void m1() {        
    // 对象实例化的传入的数据类型是String类型
        Collection<String> c1 = new ArrayList<String>();        
        // 对象实例化的传入的数据类型是String类型
        Collection<String> c2 = new ArrayList<String>();        
        // Collection接口的添加方法 add()
        ((ArrayList<String>) c1).add("aa");
        ((ArrayList<String>) c1).add("bb");
        ((ArrayList<String>) c1).add("cc");
        ((ArrayList<String>) c2).add("aa");
        ((ArrayList<String>) c2).add("dd");
        ((ArrayList<String>) c2).add("ee");        
        //输出接口中的内容
        System.out.println(c1);        
        // 输出接口中的内容
        System.out.println(c2);        
        // Collection接口中的size方法,来判断集合中的大小,及长度
        System.out.println(c1.size());
        System.out.println(c2.size());        
        // 判断容器中是否为空,返回类型是布尔值
        System.out.println(c1.isEmpty());
        System.out.println(c2.isEmpty());        
        // 把c2容器中内容添加到本容器中
        ((ArrayList<String>) c1).addAll(c2);
        System.out.println(c1);        
        // Collection接口中的removeAll()方法,用来把两个容器中相同的元素清除掉
        //System.out.println(c1.removeAll(c2));
        //System.out.println(c1);
        //Collection接口中的contains方法,用来把两个集合中的相同的元素输出出来
        System.out.println(c1.retainAll(c2));
        // System.out.println(c1);
        // Collection接口中的contains方法,用于判断容器中是否包含c2容器中所有的元素
        System.out.println(c1.containsAll(c2));
        System.out.println(c1);
    }   
    public static void main(String[] args) {    
        // 程序入口,调用m1()方法
        m1();
    }
}
List接口中索引操作

例如:

import java.util.ArrayList;
import java.util.Collection;
    public class CollectionDemo2 {    
        public static void m1() {
        Collection<String> collection = new ArrayList<String>();
        collection.add("a");
        ((ArrayList<String>) collection).add("b");
        ((ArrayList<String>) collection).add("c");
        System.out.println(collection);        
        // 在指定索引位置添加元素
        ((ArrayList<String>) collection).add(2, "java");
        System.out.println(collection);        
        // 移除指定索引的元素
        ((ArrayList<String>) collection).remove(2);
        System.out.println(collection);        
        //用指定的元素(可选操作)替换此列表中指定位置的元素。
        ((ArrayList<String>) collection).set(2, "python");
        System.out.println(collection);        
        //返回此列表中指定位置的元素。
        System.out.println(((ArrayList<String>) collection).get(1));        
        // 找出指定元素第一次出现的索引下标,没找到输出-1
        System.out.println(((ArrayList<String>) collection).indexOf("python"));        
        // 找出指定元素最后一次出现的索引下标,没找到则输出-1
        System.out.println(((ArrayList<String>) collection).lastIndexOf("python"));
    }    
    public static void main(String[] args) {
        m1();
    }
}

ArrayList底层实现

原理:

根据数组的扩容机制,ArrayList的核心是Object类的数组,ArrayList中的Object类数组默认长度为10,当我们的数据超过10,则会创建定义一个新的长度更大的数组,然后将旧的数组中的数据复制到新的数组中,( System.arraycopy()方法),然后把新的引用赋值给旧的引用,(记得重写toString方法)

public class Main<E> {    
    Object[] elemntDate;  // 创建一个Object类的数组
    private int size;    //  数组的大小
    private int a = 10;  //  定义一个数组的默认长度

    // 无参构造
    public Main() {
        elemntDate = new Object[a];
    }    // 设置数组长度
    public Main(int ca) {        
        if (ca < 0) {            
            throw new RuntimeException();
        } else if (ca == 0) {
            elemntDate = new Object[a];
        } else {
            elemntDate = new Object[ca];
        }
    }   
    // 数组的add方法
    public void add(E object) {        
    // 做判断,如果size= 数组长度时,
        if (size == elemntDate.length) {            
        // 我们定义新的数组,可以设置为此数组的2倍,我这里就是设置数组的2倍
            Object[] newArray = new Object[elemntDate.length * 2];            
            // 然后arraycopy方法将旧的数组复制到新的数组
            System.arraycopy(elemntDate, 0, newArray, 0, elemntDate.length);           
            // 复制过后然后把新的数组引用,赋值给旧的数组引用,然后旧的就成了无用的了
            elemntDate = newArray;
        }        
        // 数组容量加一次,它的数组大小就增加一次
        elemntDate[size++] = object;
    }    
    // get方法
    public E get(int index) {        
        return (E) elemntDate[index];
    }    
    // set方法
    public void set(E element, int index) {
        checkRange(index);
        elemntDate[index] = element;
    }    
    // checkRange方法
    public void checkRange(int index) {        
    if (index < 0 | index > size - 1) {            
        throw new RuntimeException("索引不合法!" + index);
        }
    }    
    //remove方法
    public void remove(E element) {        
        for (int i = 0; i < size; i++) {            
            if (element.equals(get(i))) {
                remove(i);
            }
        }
    }    
    // isEmpty方法

    public boolean isEmpty() {        
        return size == 0 ? true : false;
    }    
    public void remove(int index) {        
        int numMove = elemntDate.length - index - 1;        
            if (numMove > 0) {
            System.arraycopy(elemntDate, index + 1, elemntDate, index, numMove);
            elemntDate[size - 1] = null;
        }
        elemntDate[--size] = null;
    }

    @Override    // 重写toString方法
    public String toString() {        
        // 定义一个StringBuilder数组
        StringBuilder stringBuilder = new StringBuilder();       
         // Stringbuilder中append方法
        stringBuilder.append("[");        
        // 用for循环遍历出数组中的元素
        for (int i = 0; i < size; i++) {
            stringBuilder.append(elemntDate[i] + ",");
        }        
        // 用setCharAt方法来设置逗号的位置
        stringBuilder.setCharAt(stringBuilder.length() - 1, ']');       
             // 然后返回把stringBuilder的数组元素返回回去
        return stringBuilder.toString();
    }    // 程序入口
    public static void main(String[] args) {
        Main main = new Main();        // 添加40个元素的
        for (int i = 0; i < 40; i++) {
            main.add(i);
        }        
        // 打印输出数组中的元素
        System.out.println(main);
        System.out.println(main.get(30));
        main.set("dd", 10);
        System.out.println(main);
        main.remove(3);
        System.out.println(main);
        System.out.println(main.isEmpty());

    }
}


Map接口

Map接口实现的类:HashMap和TreeMap和HashTable,Properties

Map是用来存储键值对的,键值对的对象不能重复

Map接口的常用方法

  • put(): 存放键值对

  • remove(): 删除键值对,删除键对象所对应的键值

  • get(): 获取键对象所对应的键值

  • size(): 键值对的数量

  • isEmpty: 判断键值对是否为空

  • containsKey: 判断这个Map容器中是否包含键对象所对应的键值对

  • containsValue: 判断Map集合中是否包含键对象所对应的键值对

  • putAll : 将另一个键对象的键值对放入本容器中

  • clear: 清除Map集合中所有的键值对

import java.util.HashMap;
import java.util.Map;
   public class MapDemo {
   public static void main(String[] args) {

      Map<Integer, String> m1 = new HashMap<>();      
      // put方法在map放键值对1
      m1.put(1, "one");      
      // put方法在map放键值对2
      m1.put(2, "twe");      
      // 通过键对象获取key值
      System.out.println(m1.get(1));      
      // 输出 m1Map中的键值对元素
      System.out.println(m1);      
      // 移除m1 Map中的key值的位置
      System.out.println(m1.remove(1));      
      // 输出map中键值对元素
      System.out.println(m1);      
      // put方法存放键值对
      System.out.println(m1.put(1, "one"));      
      // 输出Map的键值对元素
      System.out.println(m1);      
      // size方法,用于查看Map中键值对的大小
      System.out.println(m1.size());      
      // isEmpty方法用于判断Map中键值对是否为空
      System.out.println(m1.isEmpty());      
      //containsKey 判断Map中是否存在这个key值
      System.out.println(m1.containsKey(1));     
      // containsValue 判断Map中是否存在这个包含这个值
      System.out.println(m1.containsValue("one"));      
      // 定义一个键值对map
      Map<Integer, String> m2 = new HashMap<>();      
      // put方法,向Map中添加键值对
      m2.put(3, "three");      
      // putAll方法,将m1的键值对全部放在m2
      m1.putAll(m2);      
      // 输出m1Map中的键值对,因为Map中已经重写了toString方法,所以会输出键值对内容
      System.out.println(m1);      
      // clear方法,将Map中的键值对全部清掉
      m1.clear();      
      System.out.println(m1);
      }
  }

HashMap

HashMap是由哈希算法实现,是Map接口实现的常用类,我们要求键不能重复,如果重复,新的键值对会替换旧的键值对

HashMap继承了 AbstractMap,实现了Map接口

HashMap与HashTable的区别:

HashMap  拥有很好的增加,删除,查找,修改效率都很高,但是线程不安全,允许key和value键为null 

HashTable   线程安全,但是删除,查找,修改、增加效率很慢,不允许key和value键为null

例如:

import java.util.HashMap;
import java.util.Map;
    class M1 {    
        private int id;    
        private String name;    
        private double salary;    
    // 无参构造方法
    public M1() {

    }    
    //带参构造方法
    public M1(int id, String name, double salary) { 
           this.id = id;  
           this.name = name;      
           this.salary = salary;
    }    
    // 对外提供公共的set方法和get方法

    public void setId(int id) {        
           this.id = id;
    }   
    public int getId() {        
            return id;
    }    
    public void setName(String name) {        
            this.name = name;
    }    
    public String getName() {        
            return name;
    }    
    public void setSalary(double salary) {        
            this.salary = salary;
    }    
    public double getSalary() {        
            return salary;
    }    
    //重写toString方法
    public String toString() {        
    return "学号:" + id + "名字:" + name + "工资:" + salary;
    }
}
public class MapDemo {    
    public static void main(String[] args) {
        M1 m1 = new M1(1001, "张三", 5000);
        M1 m2 = new M1(1002, "张四", 6000);
        M1 m3 = new M1(1003, "张五", 7000);
        M1 m4 = new M1(1001, "张六", 5000);
        M1 m5 = new M1(1004, "张七", 8000);

        Map<Integer, M1> map1 = new HashMap<>();
        Map<Integer, M1> map2 = new HashMap<>();        
        // put方法将对象放在Map集合中
        map1.put(1, m1);
        map1.put(2, m2);
        map1.put(3, m3);        
        // 键重复了,所以说会直接覆盖旧的键值对
        map1.put(1, m4);        
        // 输出map1中的键值对
        System.out.println(map1);        
        // put 方法给map2 集合中添加键值对
        map2.put(4, m5);        
        // pullAll 将map2中的键值对放在Map1中
        map1.putAll(map2);
        System.out.println(map1);        
        // size方法  输出键值对的大小
        System.out.println(map1.size());        
        // isEmpty ,判断键对象是否为空
        System.out.println(map1.isEmpty());         // falses
        // containsKey方法  判断键对象中是否包括这个键
        System.out.println(map1.containsKey(2));     // true
        // containsValue方法 判断键对象中是否包括这个键值对的值
        System.out.println(map1.containsValue(m2));  //true


    }
}

hashMap底层原理

数组: 占用空间是连续的,查询很方法便,但是增,删效率很慢

链表:  占用空间不连续.查询不是很方便,但是增,删效率很快

HashMap:就是数组+链表 ,HashMap可以解决掉数组和链表上各自的缺点

HashMap 的核心是Entry[] 数组,叫做“位桶数组” ,Entry是一个单向链表, Entry中包括

  • hash值: 键值对的hash值

  • key、value值: 键值对的键 键值对的值

  • next: 下一节点

存储数据的过程

我们是把key对象和value对象,这两个对象放在entry[]数组中

  • 获取key对象的hashcode码
     用haspMap中的hascode()方法获取hashcode值

  • 根据hashcode码算出hash值(值必须在[0,length-1]区间)

  • 然后根据这个hash值,来确定插入数组中的位置.

  • 如果当前位置存在元素时,这时我们就检查该元素和hash值以及key值是否相同,如果相同,就直接覆盖,如果不同就用拉链法解决问题 (确保hashMap的唯一性)

《拉链法》: 添加在上一个节点的后面

HashMap的get方法实现

获得key的hashcode,通过散列算法得到hash值,进而定位到数组的位置。然后在链表上依次比较,可以用Object类中equal()方法,将key对象的hash值和链表上比较,直到碰撞返回返回true的节点对象为止 。

haspMap的put方法实现

我们通过key对象获取的hash值,来确定key对象在数组中的元素位置,如果没有就直接插入如果定位到的数组位置有元素,遍历以这个元素为头结点的链表,依次和插入的key比较,如果key相同就直接覆盖,不同就采用头插法插入元素。

HashMap的扩容

hashMap的位桶数组默认长度为16,如果位桶数组中的元素达到0.75*数组length时,就重新调整数组大小变为原来数组的两倍
但是扩容很耗时,扩容的本质就是定义新的更大的数组,并且将旧的数组中的内容复制到新的数组中,然后把新的数组的引用赋值给旧的数组引用

在java jdk8版本中如果相对应的链表长度超过了8,链表就转换为红黑树,这样就提高了查找效率

HashMap底层原理

import java.io.FileOutputStream;public class LinkedListDemoTest<K, V> {
    LinkedListDemo[] linkedListDemos;  // 声明一个位桶数组;
    int size;                         // 键值对个数

    // 无参构造方法
    public LinkedListDemoTest() {
        linkedListDemos = new LinkedListDemo[16]; // 为数组设置为默认长度16,在java中建议使用,2的整数幂
    }    
    // put方法
    public void put(K key, V value) {        
    // 定义新的节点对象
        LinkedListDemo newlinkedListDemo = new LinkedListDemo();        
        // 定义一个myHash方法 算出新节点的hash值
        newlinkedListDemo.hash = MyHash(key.hashCode(), linkedListDemos.length);        
        // key值就等于key值
        newlinkedListDemo.key = key;        
        // value值就等于value值
        newlinkedListDemo.value = value;        
        // 下一节点为空
        newlinkedListDemo.next = null;        
        /**
         * 通过hash值来明确在数组元素中的位置,如果这个新节点的位置为空,直接将新节点放进去
         */
        LinkedListDemo temp = linkedListDemos[newlinkedListDemo.hash]; 
        // 将新节点的hash值放在相对应的位桶数组中
        boolean keyRepeat = false;  
        // key值是不是重复, 默认为false
        LinkedListDemo itemp = null;  
        // 正在遍历的最后一个元素
        if (temp == null) {            
        //此处数组为空,则直接将新节点点放进去
            linkedListDemos[newlinkedListDemo.hash] = newlinkedListDemo;            
            size++;
        } else {            
        // 此处数组元素不为空,则遍历对应的链表。
            while (temp != null) {                
            // 判断key值是否重复,重复就直接覆盖
                if (temp.key.equals(key)) {
                    keyRepeat = true;         //修改为true
                    temp.value = value;      //只是覆盖value即可,其他值(hash,key,next)保持不变。
                    break;
                } else {                    
                // 如果不重复,则遍历下一个节点。
                    itemp = temp;
                    temp = temp.next;
                }
            }            
            if (!keyRepeat) {                
                // 如果不发生key重复的话
                // 将next指向新的节点
                itemp.next = newlinkedListDemo;                
                    size++;
            }
        }
    }    
    //  利用v & length-1 和v % length-1两种方法实现 将key对象的hashcode转换为hash值(散列算法)
    // hash值 = hashcode&(数组长度-1)。
    public int MyHash(int v, int length) {
        System.out.println("hash值:" + (v & length - 1)); // 直接位运算,效率高
        System.out.println("hash值:" + (v % length - 1));  // 取模运算,效率低
        return v & (length - 1);

    }    
    // get方法
    public V get(K key) {        
        int hash = MyHash(key.hashCode(), linkedListDemos.length);
        V value = null;        
        if (linkedListDemos[hash] != null) {
            LinkedListDemo temp = linkedListDemos[hash];            
            while (temp != null) {               
                 if (temp.key.equals(key)) {  // 如果相同,就说明找到了键值对,返回相对应的value
                        value = (V) temp.value;                    break;
                    } else {                     //如果没有找到,就找下一个节点
                        temp = temp.next;
                }
            }
        }        
        return value;
    }    
    // 重写toString方法
    @Override    
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("{");        
        // 遍历位桶数组
        for (int i = 0; i < linkedListDemos.length; i++) {
            LinkedListDemo temp = linkedListDemos[i];            
            //遍历链表
            while (temp != null) {
                stringBuilder.append(temp.key + ":" + temp.value + ",");
                temp = temp.next;
            }
        }
        stringBuilder.setCharAt(stringBuilder.length() - 1, '}');        
        return stringBuilder.toString();
    }    
    // Entry(LinkedListDemo)位桶数组
    class LinkedListDemo<K, V> {        
        int hash;        // hash值
        Object key;     // key对象
        Object value;    // value对象
        LinkedListDemo next;  //  下一个节点

    }   
    public static void main(String[] args) {
        LinkedListDemoTest<Integer, String> linkedListDemoTest = new LinkedListDemoTest<>();
        linkedListDemoTest.put(10, "aa");
        linkedListDemoTest.put(20, "bb");
        linkedListDemoTest.put(30, "cc");
        linkedListDemoTest.put(30, "dd");
        linkedListDemoTest.put(30, "java");
        linkedListDemoTest.put(20, "python");
        linkedListDemoTest.put(40, "html");
        System.out.println(linkedListDemoTest);
        System.out.println(linkedListDemoTest.get(20));
        System.out.println(linkedListDemoTest.size);
    }
}

实现原理:

HashMap的核心就是Entry数组,我们也叫""位桶数组",位桶数组的里面放着 hash值,key对象,value对象,next下一个节点,默认的位桶数组长度为16(在java中,建议使用2的整数幂),在创建一个新的节点后,我们利用这个节点key对象中的hashcode方法,算出hashcode,通过hashcode算出key对象hash值(要求在[0, 数组长度-1]区间),通过hash值就可以确定插入数组中的位置,如果这个新节点的位置为空,则直接将新的节点放进相对应的数组位置。但是如果数组不为空,则遍历相对应的链表,判断key值和链表上的key值是否重复,如果重复就直接覆盖,只是覆盖value即可,其余不变(hash值,key,next)。如果不重复,则遍历下一个节点,然后如果没有发生key值重复的话,则把这个的next指向新的下一个节点。 在java jdk8中,当链表的长度大于8时,链表就会转换为红黑树,这样就大大的提高了查找效率。

散列算法

    第一种方法:
    v % length-1                // 直接位运算,效率高
    第二种方法:
    v & length-1               // 取模运算,效率低

    例如:    //  利用v & length-1 和v % length-1两种方法实现 将key对象的hashcode转换为hash值(散列算法)
    // hash值 = hashcode&(数组长度-1)。   v:hashcodepublic int MyHash(int v, int length) {
    System.out.println("hash值:" + (v & length - 1)); // 直接位运算,效率高
    System.out.println("hash值:" + (v % length - 1));  // 取模运算,效率低
    return v & (length - 1);

}

遍历集合的方法

循环map的三种方法:

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;
public class Demo10 {    
    /**
     * 私有化属性,对外提供公共的get方法和set方法
     * id,name属性
     */
    private int id;    
    private String name;    
    // 无参构造方法
    public Demo10() {

    }    // 带参构造方法
    public Demo10(int id, String name) {        
        this.id = id;        
        this.name = name;
    }    
    /**
     * 对外提供公共的get方法和set方法
     */
    public void setId(int id) {        
        this.id = id;
    }    
    public int getId() {        
        return id;
    }    
    public void setName(String name) {        
        this.name = name;
    }    
    public String getName() {        
    return name;
    }    
    // 重写toString方法,防止下面输出的是内存地址
    @Override    
    public String toString() {        
        return "id:" + id + ",名字:" + name;
    }    
    public static void main(String[] args) {        
    // 对象实例化
        Demo10 demo1 = new Demo10(1, "张三");
        Demo10 demo2 = new Demo10(2, "李四");
        Demo10 demo3 = new Demo10(3, "王五");        
        // 创建map集合
        Map<Integer, Demo10> map = new HashMap<>();        
        // put方法
        map.put(1001, demo1);        
        map.put(1002, demo2);        map.put(1003, demo3);        // 循环遍历数据,
        // 第一种方法
        // 用foreach的增强循环,一般都是用这种方法简便
        // 先用map接口中的KeySet方法
        Set<Integer> set = map.keySet();        
        for (Integer i : set) {
            System.out.println("map集合中的内容为:" + i + "===" + map.get(i));
        }
        System.out.println("===========================================");        
        // 第二种方法 迭代器
        // KeySet方法
        Set<Integer> set1 = map.keySet();        
        for (Iterator iterator = set1.iterator(); iterator.hasNext(); ) { 
            // 判断迭代器是否还有下一个
            // 指向下一个
            Object i = iterator.next();
            System.out.println("map集合中的内容为:" + i + "===" + map.get(i));
        }
        System.out.println("===========================================");        
        // 第三种方法迭代器  entrySet方法
        // 记得导包
        // import java.util.Map.Entry
        Set<Entry<Integer, Demo10>> set2 = map.entrySet();        
        for (Iterator iterator = set2.iterator(); iterator.hasNext(); ) {
            Entry s = (Entry) iterator.next();
            System.out.println("map集合中的内容为:" + s.getKey() + "===" + s.getValue());
        }
    }

}

Set中的循环遍历方法

import java.util.*;
public class Demo10 {    
    /**
     * 私有化属性,对外提供公共的get方法和set方法
     * id,name属性
     */
        private int id;    
        private String name;    
    // 无参构造方法
    public Demo10() {

    }    
    // 带参构造方法
    public Demo10(int id, String name) {        
        this.id = id;        
        this.name = name;
    }   
     /**
     * 对外提供公共的get方法和set方法
     */
    public void setId(int id) {        
        this.id = id;
    }    
    public int getId() {        
        return id;
    }    
    public void setName(String name) {        
        this.name = name;
    }    
    public String getName() {        
        return name;
    }    
    // 重写toString方法,防止下面输出的是内存地址
    @Override    
    public String toString() {        
        return "id:" + id + ",名字:" + name;
    }    
    public static void main(String[] args) {        
        // 对象实例化
        Demo10 demo1 = new Demo10(1, "张三");
        Demo10 demo2 = new Demo10(2, "李四");
        Demo10 demo3 = new Demo10(3, "王五");        
        // 创建Set
        Set<Demo10> set = new HashSet<>();        
        set.add(demo1);        
        set.add(demo2);        
        set.add(demo3);        
        // 循环遍历
        // 第一种方法:foreach增强循环
        for (Demo10 demo10 : set) {
            System.out.println("Set中的内容为:===" + demo10);
        }
        System.out.println("=================================");        
        // 第二种方法 :迭代器
        for (Iterator iterator = set.iterator(); iterator.hasNext(); ) {
            Demo10 demo10 = (Demo10) iterator.next();
            System.out.println("Set中的内容为:===" + demo10);
        }
    }
}

List中的循环遍历方法:

import java.util.*;
import java.util.List;
public class Demo10 {
        /**
         * 私有化属性,对外提供公共的get方法和set方法
         * id,name属性
         */
        private int id;       
        private String name;    
        // 无参构造方法
        public Demo10() {
    
        }    
        // 带参构造方法
        public Demo10(int id, String name) {            
            this.id = id;            
            this.name = name;
        }    
        /**
         * 对外提供公共的get方法和set方法
         */
        public void setId(int id) {            
            this.id = id;
        }    
        public int getId() {            
            return id;
        }    
        public void setName(String name) {            
            this.name = name;
        }    
        public String getName() {            
            return name;
        }    
        // 重写toString方法,防止下面输出的是内存地址
        @Override        
        public String toString() {            
            return "id:" + id + ",名字:" + name;
        }    
        public static void main(String[] args) {            
            // 对象实例化
            Demo10 demo1 = new Demo10(1, "张三");
            Demo10 demo2 = new Demo10(2, "李四");
            Demo10 demo3 = new Demo10(3, "王五");            
            // 创建List
            // 记得导包 import java.util.List;不是import java.awt.List
            List<Demo10> list = new ArrayList<>();            
            // 添加方法
            list.add(demo1);            
            list.add(demo2);            
            list.add(demo3);            
            //循环遍历
            // 第一种方法 foreach增强方法
            for (Demo10 listFor : list) {
                System.out.println("list中的内容为:" + listFor);
            }
            System.out.println("=======================================");            
            // 第二种方法   迭代器
            for (Iterator iterator = list.iterator(); iterator.hasNext(); ) {
                Demo10 iteratorDemo = (Demo10) iterator.next();
                System.out.println("list中的内容为:" + iteratorDemo);
            }
            System.out.println("=======================================");            
            // 第三种方法  普通循环
            for (int i = 0; i < list.size(); i++) {
                Demo10 temp = list.get(i);
                System.out.println("list中的内容为:" + temp);
            }
        }
    }


Tags: java

很赞哦! (6)

上一篇:java内存区域详解

下一篇:IO流介绍

留言

来说点儿什么吧...

您的姓名: *

选择头像: *

留言内容:

    2019年2月25日 13:35嘿嘿

    2019年2月26日 13:20ok

    可以可以!

    2019年3月18日 09:2311

    1

    2019年3月28日 09:24www.ikeguang.com

    可以可以

    2019年5月29日 18:47qwe

    666

    2019年5月30日 16:52BlankYk

    he,tui~

    2019年5月30日 17:04123

    321

    2019年6月26日 10:02周树人

    厉害厉害

    2019年6月26日 10:34sdlakrj

    sdaag

    2019年6月29日 15:31sdagafdbaf

    dgafdgdfh

    站长回复:你这是什么什么高级语言,我表示看不懂哈哈

    2019年7月6日 16:37啦啦

    写的真好!谢谢博主

    站长回复:谢谢!

    2019年8月14日 12:35傻傻

    厉害 小林