本文主要是介绍集合，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

为什么需要集合

自动扩容，实现无限存放数据（只要服务器够用）

单列（List、set）和多列（map）

ArrayList，LinkedList存数据保证有序

迭代器

集合专有

package jihe;

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

/**
 *
 **/
public class Demo2 {
    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("111");
        strings.add("111");
        strings.add("111");
        strings.add("111");
        strings.add("111");
//        for (int i = 0; i < strings.size(); i++) {
//            System.out.println(strings.get(i));
//
//        }
        /**
         * 迭代器
         */
        Iterator<String> iterator = strings.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

}

手写迭代器

package jihe;

import java.util.List;

/**
 *
 **/
public class MyIterator {
    List list;
    public MyIterator(List list){
        this.list=list;
    }
    int count=0;
    public Object next(){
        return list.get(count++);//get后加1
    }
    public Boolean hasnext(){
        if(count < list.size()) {
            return true;
        }else{
            return false;
        }
    }
}

增强for循环用于数组和集合

package jihe;

import java.util.ArrayList;

/**
 *
 **/
public class Demo3 {
    public static void main(String[] args) {
        int[] arrList={1,2,3,4,5,6};
        //泛型只用于应用类，基本数据使用其包装类
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(3);
        arrayList.add(4);
        arrayList.add(5);
        for (int i :
                arrList) {
            System.out.println(i);
        }
        for (Integer i :
                arrayList) {
            System.out.println(i);
        }
    }
}

泛型

jdk1.5没有泛型，ArrayLitsnew类型为Object

泛型用于接口，类，方法

【泛型类】

package jihe;

/**
 *泛型类
 **/
public class MyFanXin <T>{
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

package jihe;

/**
 *
 **/
public class Demo4 {
    public static void main(String[] args) {
        //指定String类型
        MyFanXin<String> stringMyFanXin = new MyFanXin<>();
        stringMyFanXin.setT("aa");
        //指定Integer类型
        MyFanXin<Integer> integerMyFanXin = new MyFanXin<>();
        integerMyFanXin.setT(11);
    }
}

【泛型方法】

package jihe;

/**
 *泛型方法
 **/
public class Demo5 {
    public <T> T show(T t){//返回值不固定可以写一个泛型类最哦为返回对象
        return t;

    }}

package jihe;

/**
 *
 **/
public class Demo4 {
    public static void main(String[] args) {
        Demo5 demo5 = new Demo5();
        demo5.show("a");
        demo5.show(1);
        
    }
}

【泛型接口】

package jihe;

/**
 *
 **/
public interface Demo6<T> {
    T show(T t);
}

package jihe;

/**
 *
 **/
public class Demo7<T> implements Demo6<T>{
    @Override
    public T show(T t) {
        return null;
    }
}

package jihe;

/**
 *
 **/
public class Demo8 {
    public static void main(String[] args) {
        Demo7<String> stringDemo7 = new Demo7<>();
        stringDemo7.show("33");
    }
}

同时使用泛型接口和泛型方法

package jihe;

/**
 *
 **/
public interface Demo6<T> {
    <M> T show(T t,M m);
}

package jihe;

/**
 *
 **/
public class Demo7<T> implements Demo6<T>{
    @Override
    public <M> T show(T t, M m) {
        System.out.println(m);
        return null;
    }
}

package jihe;

/**
 *
 **/
public class Demo8 {
    public static void main(String[] args) {
        Demo7<String> stringDemo7 = new Demo7<>();
        stringDemo7.show("33",33);//33
    }
}

【通配符】

package jihe;

import java.sql.Array;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 *
 **/
public class Demo9 {
    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        show(strings);

    }

    /**
     * List<?>-->可以接受所有的泛型类型，但是不能做添加方法
     * @param list
     */
    public static void show(List<?> list){
       // list.add("a");
        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()){
            iterator.next();
        }
    }
}

通配符上限和下限

package jihe;

import java.util.List;

/**
 *
 **/
public class Demo10 {
    public static void main(String[] args) {

    }
    //上限：接受类型为MyIterator或者其子类
    static void show(List<? extends MyIterator>list){

    }
    //上限：接受类型为MyIterator或者其父类
    static void show2(List<? super MyIterator>list){

    }
}

可变参数

package jihe;

/**
 *可变参数，如果有多个参数，可变参数放在最后
 **/
public class Demo11 {
    public static void main(String[] args) {
        show(1,1,1,1,1);

    }
    public static void show(int... a){
        for (int i :
                a) {
            System.out.println(i);
        }

    }
}

可变参数用法

package jihe;

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

/**
 *
 **/
public class Demo11 {
    public static void main(String[] args) {
        show(1,1,1,1,1);
        //Arrays.asList生成的List数量不能发生变化
        List<Integer> integers = Arrays.asList(1, 2, 3, 4);
        for (Integer i :
                integers) {
            System.out.println(i);
        }

    }
    public static void show(int... a){
        for (int i :
                a) {
            System.out.println(i);
        }

    }
}

public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}

泛型底层擦除机制

package jihe;

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

/**
 *
 **/
public class Demo11 {
    public static void main(String[] args) {
        List list=new ArrayList();
        list.add("My可");
        list.add(10);
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

    }
    public static void show(int... a){
        for (int i :
                a) {
            System.out.println(i);
        }

    }
}

ArrayList

arraylist按index查找修改效率高

增删效率低

初始化是懒加载：用到是才加载

Linkedlist

双向链表+红黑树

增删效率高，查找效率低O(n)

set

HashSet

1. HashSet是set接口的典型实现，大多数时候使用Set集合时就是使用这个实现类
2. HashSet按Hash算法来决定集合元素的顺序，具有很好的查找性能
3. 当向HashSet集合中存入一个元素时，根据该对象的hashcode值决定该对象在HashSet中的存储位置

hash是什么，是把任意数据通过散列算法变换成固定的输出，该输出就是散列值

package set;

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

/**
 *
 **/
public class HashSetSample {
    public static void main(String[] args) {
        /**
         * hashset无序不重复
         */
        Set<String> strings = new HashSet<>();
        strings.add("131311");
        strings.add("131312");
        strings.add("131331");
        strings.add("1311");
        strings.add("1311");
        strings.add(null);//允许存入null，但只能有一个
        System.out.println(strings);//[131331, 1311, 131312, 131311]无序不重复
        /**
         * get方法属于List，Set无法使用
         */
       // strings.get();
    }
}

LinkedHahSet

LinkedHahSet是HashSet的子类，除HahSet的特性外，他同时使用链表维护元素的次序，可以保证插入顺序提取数据

TreeSet

底层：红黑树

TreeSet是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态

TreeSet采用红黑树的数据结构来存储集合元素

TreeSet默认采用自然排序对元素升序排列，也可以实现Comparable接口在定义排序方式

Set集合的数据的唯一性

【问题1】

Set集合在新增数据时先判断hashcode是否已经存在

若hashcode存在调用equals进行值比较；

hashcode与equals都存在时，Set才认为数据已存在，不予新增

【问题2】

为甚什么使用hashcode，直接用equals不好吗？

出于效率考虑

hashcode()返回的整数结果决定了set集合中的存放位置，hashcode()计算速度块，但可能出现哈希碰撞

equals()则对值进行比较，处理速度相对较慢

注意：重写hascode和equals根据需要进行判断

掌握HashSet和TreeSet的应用

package set;

import java.util.LinkedHashSet;

/**
 *
 **/
public class LinkedHashSetSample {
    public static void main(String[] args) {
        LinkedHashSet<String> strings = new LinkedHashSet<>();
        strings.add("1238127789");
        strings.add("1233237789");
        strings.add("1235341894");
        strings.add("4112444149");
        System.out.println(strings);//[1238127789, 1233237789, 1235341894, 4112444149]存储时还是遵循hashset，只是访问有序
    }
}

package set;

import java.util.Comparator;
import java.util.TreeSet;

/**
 *
 **/
public class TreeSetSample {
    static class IntegerComparator implements Comparator<Integer>{

        @Override
        public int compare(Integer o1, Integer o2) {
            return o2-o1;//降序
        }
    }
    public static void main(String[] args) {
        TreeSet<Integer> set = new TreeSet<>(new IntegerComparator());
        set.add(100);
        set.add(140);
        set.add(180);
        set.add(200);
        System.out.println(set);//有序
    }
}

Map

key和value可以是任何引用类型，但是key通常是String，key不可重复，反复设置key，后面的value会覆盖前面的

HashMap

对key进行无需存储

不能保证数据按存储顺序读取，且key全局唯一

HashMap与LinkedHashMap的区别

package set;

import java.util.HashMap;

/**
 *
 **/
public class HashMapSample {
    public static void main(String[] args) {
        HashMap<String, Object> stringObjectHashMap = new HashMap<String, Object>();
        Object put = stringObjectHashMap.put("name", "张三");
        Object put1 = stringObjectHashMap.put("name", "张");//如果put是出现重复，会返回原来的值
        System.out.println(put1);
    }
}

LinkedHashMap按顺序提取数据

TreeMap

存储key-value时，需要根据key对节点进行排序；

TreeMap支持两种Key排序，自然排序和定制排序

底层：红黑树

package set;

import java.util.Comparator;
import java.util.TreeMap;

/**
 *
 **/
public class TreeMapSample {
    static class Resx implements Comparator<String>{
        @Override
        public int compare(String o1, String o2) {
            return o2.compareTo(o1);
        }//String:按key排序

    }
    public static void main(String[] args) {
        TreeMap<String, Object> stringObjectTreemAP = new TreeMap<String, Object>(new Resx());
        stringObjectTreemAP.put("A1","1");
        stringObjectTreemAP.put("C3","2");
        stringObjectTreemAP.put("B5","3");
        stringObjectTreemAP.put("X1","4");
        stringObjectTreemAP.put("B1","6");
        System.out.println(stringObjectTreemAP);//自然排序{A1=1, B1=6, B5=3, C3=2, X1=4},使用定制排序：{X1=4, C3=2, B5=3, B1=6, A1=1}
    }
}

Map三种遍历方式

for i

foreach

迭代器

package set;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 *
 **/
public class LoopSample {
    public static void main(String[] args) {
        Map<String, Integer> stringIntegerHashMap = new HashMap<>();
        stringIntegerHashMap.put("1",1);
        stringIntegerHashMap.put("a",2);
        stringIntegerHashMap.put("3",3);
        stringIntegerHashMap.put("4",4);
        stringIntegerHashMap.put("5",5);
        stringIntegerHashMap.put("6",6);
        /**
         * foreach
         */
        Set<String> keys= stringIntegerHashMap.keySet();
        for (String s:keys
             ) {
            System.out.println(stringIntegerHashMap.get(s));//获取value
        }
        /**
         * lambda表达式
         */
        stringIntegerHashMap.forEach((key,value)-> System.out.println(key+value));

        /**
         *
         * 迭代器
         */
        Iterator<Map.Entry<String, Integer>> iterator = stringIntegerHashMap.entrySet().iterator();
        while (iterator.hasNext()){
            Map.Entry<String, Integer> next = iterator.next();
            System.out.println(next.getKey());
            System.out.println(next.getValue());
        }
    }
}

通过Conllections实现集合的排序

package set;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 *
 **/
public class ListSort {
    class SampleCompartor implements Comparator<Integer>{
        /**
         * o1-o2
         * 结果>0,则交换位置
         * 结果=0或<0不变
         * @param o1
         * @param o2
         * @return
         */
        @Override
        public int compare(Integer o1, Integer o2) {
            return o2-o1;
        }
    }
    public List<Integer> sort(List<Integer> list){
        Collections.sort(list,new SampleCompartor());
        System.out.println(list);
        return list;
    }
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(70);
        arrayList.add(90);
        arrayList.add(30);
        arrayList.add(50);
        ListSort listSort = new ListSort();
        List<Integer> sort = listSort.sort(arrayList);
        System.out.println(sort);
        System.out.println(arrayList);
    }
}

自定义对象比较器

比较器内容-->o1.比较属性（如果属性为String）.compleTo(o2.属性)

这篇关于集合的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！