投稿
  1. 极客之音首页
  2. 后端开发
  3. Java

java集合框架

小半 • • Java • 阅读 193

如果你不相信努力和时光，那么成果就会是第一个选择辜负你的。不要去否定你自己的过去，也不要用你的过去牵扯你现在的努力和对未来的展望。不是因为拥有希望你才去努力，而是去努力了，你才有可能看到希望的光芒。java集合框架，希望对大家有帮助，欢迎收藏，转发！站点地址：www.bmabk.com，来源：原文

java集合框架

  • 概念：对象的容器，定义了对多个对象进行操作的常用方法。可以实现数组的功能。

  • 和数组的区别：

  1. 数组长度固定，集合长度不固定
  2. 数组可以存储基本数据类型和引用数据类型，集合只能存储引用数据类型（存储基本数据类型自动装箱）

Collection类

所有集合类的父接口

集合体系结构：包括List接口和Set接口的区别
java集合框架

Collection特点：代表一组任意类型的对象，无序、无下标

各元素对象之间没有指定的顺序，允许有重复元素和多个Null元素对象。所以不可以排序，也不可以找出第几个元素。

方法：

java集合框架

        Collection collection = new ArrayList();
        //添加
        collection.add("苹果");
        collection.add("西瓜");
        collection.add("葡萄");
        System.out.println(collection.size());
        System.out.println(collection);//相当于调用toString
//        删除
        collection.remove("苹果");
        System.out.println(collection);
//        清除
//        collection.clear();

//        遍历
//        方法一,因为collection无下标所以不要用for-i
        for (Object o : collection) {

        }
//        方法二：迭代器(专门遍历集合的一种方式),Iterator是一个接口
        Iterator it = collection.iterator();
        //是否有下一个元素
        it.next();
        it.remove();//迭代器中只能用这种方法删除,不能用本来的删除,删除的是栈存储的地址，通过equals方法
        while (it.hasNext()){
            //等于下一个元素
            String s =(String) it.next();
            System.out.println(s);
        }


//        判断
        System.out.println(collection.contains("葡萄"));
		System.out.println(collection.isEmpty());

/*
3
[苹果, 西瓜, 葡萄]
[西瓜, 葡萄]
葡萄
true
false

List类

特点：有序、有下标、元素可以重复

在拥有父类的方法之外，List特有方法

java集合框架

另外List也有特殊的迭代器列表迭代器ListIterator可以向前或者向后遍历：

List list = new ArrayList();
//       添加
        list.add(0,"苹果");
        list.add("西瓜");
// 列表迭代器
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()){
            System.out.println(listIterator.nextIndex()+":"+listIterator.next());
        }
        System.out.println("------从后往前---------------");
        while (listIterator.hasPrevious()){
            System.out.println(listIterator.previousIndex()+":"+listIterator.previous());
        }

        //查询位置
        System.out.println(list.indexOf("苹果"));

/*
0:苹果
1:西瓜
------从后往前---------------
1:西瓜
0:苹果
0

list删除数字：

List list = new ArrayList();
list.add(1);
list.add(2);
//直接输入数字会被认为是下标，又因为集合的基本数据类型经过了装箱，所以这样写
list.remove((Object)1);或者new Integer（1）也可以
System.out.println(list);
//[2]

其他方法不再演示

List的实现类：ArrayList,Vector,LinkedList

ArrayList类

  • 以数组结构实现，查询快、增删慢
  • 运行效率快、线程不安全
  • List的实现类
ArrayList arrayList = new ArrayList();

一些源码分析：

  1. 默认容量：DEFAULT_CAPACITY = 10，没添加如何元素0,大于10就是元素个数;
  2. 存放元素的数组：elementData
  3. 实际元素个数：size

Vector类

  • 数组结构实现，查询快、增删慢
  • 运行效率慢、线程安全
  • 用的少
  • List的实现类

创建方法同上，方法自己看文档

LinkedList类

  • 链表结构（双向链表）实现，增删快、查询慢。

增删改查方法类似上面，不在赘述

至于链表结构学了c或者数据结构应该都懂吧

泛型

本质上是参数化类型，把类型当做参数传递

常见形式有泛型类、泛型接口和泛型方法

语法：

<T,…>，T是类型占位符，表示一种引用类型,可以写多个

作用：

提高代码重用性

防止类型转换异常，提高安全性

泛型类

public class MyGeneric <T>{
    T t;
    public  void show(T t){
//        T t1 = new T();  这是不合法，不能new因为不确定类型
        System.out.println(t);
    }

    public T getT(){
        return  t;
    }

    public static void main(String[] args) {
        //泛型类中必须是引用数据类型，基本数据类型就用包装类。右边的String可写可不写
        MyGeneric<String> myGeneric = new MyGeneric<String>();
        myGeneric.t="hello";
        System.out.println(myGeneric.t);
        myGeneric.show("大家好");
        
    }
}
/*
hello
大家好

泛型接口

泛型接口基本和泛型类类似，只不过其他类实现它时传入引用类型但是当实现泛型接口时也不确定如下，后面声明类的时候再传

public class  Student  implements MyGeneric<String>{}
public class  Student<T>  implements MyGeneric<T>{}

泛型方法

public class MyGeneric {
    //先声明泛型方法，之后可以返回类型或者在参数使用泛型
    public <T>  T show(T t){
        return t;
    }

    public static void main(String[] args) {
        MyGeneric myGeneric = new MyGeneric();
//        泛型类型由传入的数据类型决定
        myGeneric.show("大家好");
        myGeneric.show(1);

    }
}

泛型好处

  • 提高重用性

  • 防止类型转换异常

泛型集合

参数化类型、类型安全的集合，强制集合元素的类型必须一致

ArrayList<String> list = new ArrayList<String>();
//不写泛型默认是Object

当不使用泛型时

ArrayList list = new ArrayList();
list.add("aa");
list.add(1);
for (Object o : list) {
    String s= (String) o;
}
/*
Exception in thread "main" java.lang.ClassCastException: class java.lang.Integer cannot be cast to class java.lang.String (java.lang.Integer and java.lang.String are in module java.base of loader 'bootstrap')

Set类

特点：无序、无下标、元素不可重复

各元素对象之间没有指定的顺序，不允许有重复元素，最多允许有一个Null元素对象

一个不包含重复元素的Collection，方法和Collection完全一样

继承Collection，是接口

        Set<String> set = new HashSet<>();
//        增删改查同Collection

Set的实现类：HashSet，TreeSet

HashSet类

  • 基于HashCode计算元素的存放位置
  • 存储结构：哈希表（数组+链表+红黑树）
  • 当存入的一个元素时如果对应哈希码数组位置为空直接存入，如果已有元素会调用equals进行确认，如果为true，则拒绝存入；为false，存储在数组同一个位置与已有元素形成链表（返回哈希值，有方法hashCode）(另外删除等其他方法时同理也是通过hashCode和equals方法)
HashSet<String> hashSet = new HashSet<>();

TreeSet类

  • 基于排序顺序实现元素不重复
  • 实现了SortedSet接口，对集合元素自动排序
  • 元素对象的类型必须实现Comparable接口，指定排序规则
  • 通过Comparable的一个compareTo方法确定是否为重复元素
  • 存储结构：红黑树结构（二叉查找树的一种）
TreeSet<String> treeSet = new TreeSet<>();
treeSet.add("b");
treeSet.add("a");
treeSet.add("c");
treeSet.add("c");
System.out.println(treeSet);
//根据字典序排序，重复的不添加
//out:[a, b, c]

删除等操作类似

要求：TreeSet如果要装入对象，对象必须实现Comparable(泛型接口)重写compareTo方法

public class  Student  implements  Comparable<Student>{
    String name="11";
    int age=11;
    //先按姓名再按照年龄比,相同返回0
    @Override
    public int compareTo(Student o) {
        //String的compareTo：相同返回0
        int n1 = this.name.compareTo(o.name);
        int n2 = this.age-o.age;
        //如果name相同n2否则返回n1
        return  n1==0 ? n2:n1;
    }
    
    public static void main(String[] args) {
        TreeSet<Student> treeSet = new TreeSet<>();
        Student s1 = new Student();
        treeSet.add(s1);
    }
}
//删除等其他操作同理

Comparator和Comparable

上文提到如果TreeSet要装入自定义的类的话需要实现Comparable类，事实上也可以通过实现Comparator装入

  • Comparable：可比较的
  • Comparator：实现定制比较（比较器）
TreeSet<Student> treeSet = new TreeSet<>(new Comparator<Student>() {
    @Override
    public int compare(Student o1, Student o2) {
        //比较方法:自己根据项目要求写,相同返回0，上面Comparable的compareTo也是同理
        return 0;
    }
});
Student s1 = new Student();
treeSet.add(s1);

Map集合

java集合框架

特点：

  1. 用来存储键值对
  2. 键：无序、无下标、不允许重复
  3. 值：无序、无下标、允许重复
  4. 是接口

常用方法：

java集合框架

Map<String,String> map = new HashMap<>();
map.put("CHA","中国");
map.put("USA","美国");
map.put("UK","英国");
//替换掉键值对上一个值
map.put("UK","联合王国");

System.out.println(map.size());
System.out.println(map.toString());
//删除
map.remove("UK");
System.out.println(map.toString());
//使用KeySet（）遍历：得到一个存储了键的Set
System.out.println("keySet遍历-----------------");
Set<String> keySet = map.keySet();
for (String s : keySet) {
    //get通过键得到值
    System.out.println(s+":"+map.get(s));
}
//使用entrySet方法遍历：得到一个存储键值对的Map.Entry:效率更高
System.out.println("entrySet方法遍历-------------");
Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String, String> entry : entries) {
    System.out.println(entry.getKey()+":"+entry.getValue());
}
//判断
System.out.println(map.containsKey("USA"));
System.out.println(map.containsValue("英国"));

/*
3
{USA=美国, UK=联合王国, CHA=中国}
{USA=美国, CHA=中国}
keySet遍历-----------------
USA:美国
CHA:中国
entrySet方法遍历-------------
USA:美国
CHA:中国
true
false

Map集合的实现类：HashMap，Hashtable，TreeMap

HashMap类

  • 运行效率高，线程不安全；允许使用null作为key或者value
  • 实现Map
  • 存储结构：哈希表
  • 区别于hashset（默认容量10，但是元素个数<0时为空Hashmap一样）默认容量16，加载因子（元素大于容量的0.75（阈yu值）开始扩容，扩容为阈值两倍）0.75，链表长度或者数组长度大于一定数目时链表可能变成红黑树。jdk1.8之前是头插入，之后是尾插入
HashMap<String,String> hashMap = new HashMap<>();

方法和Map方法一样,

存储方式看hashSet，完全类似，使用key的hashcode和equals比较

另外HashSet源码实际上用的就是HashMap

Hashtable类

  • 线程安全，运行效率慢，不允许null作为key或者value
  • 用的少
  • 存储结构是哈希表
  • 子类Properties

方法类似不在赘述

Proeryies类

要求key和value都是String。通常用于配置文件读取

是Hashtable的子类

这里暂且忽略

TreeMap类

  • 实现了SortedMap接口（一个Map的子接口），可以对key自动排序
  • 存储结构：红黑树
  • 类似TreeSet存储类需要实现Comparable泛型接口（或者Comparator），重写相应方法
TreeMap<Student,String> treeMap = new TreeMap<>();


public class  Student  implements  Comparable<Student>{}

Collections工具类

集合工具类，定义了除了存取以外的集合常用方法

全是静态方法

java集合框架

List<Integer> list = new ArrayList<>();
    list.add(20);
    list.add(5);
    list.add(12);
    //sort排序:默认升序，可以直接通过Comparator自定义比较方法
        Collections.sort(list);
//        Collections.sort(list, new Comparator<Integer>() {
//            @Override
//            public int compare(Integer o1, Integer o2) {
//                return 0;
//            }
//        });
        System.out.println(list);
//        binarySearch查找:找到返回下标否则返回负值
        int i=Collections.binarySearch(list,12);
        System.out.println(i);
//        copy复制:必须要集合一样大，直接这样是不行的，需要如下
        List<Integer> list1 = new ArrayList<>();
        //大小添加到3
        for (int j = 0; j < 3; j++) {
            list1.add(0);
        }
        Collections.copy(list1,list);
        System.out.println(list1);
//        reverse反转
        Collections.reverse(list1);
        System.out.println(list1);
//        shuffle打乱
        Collections.shuffle(list);
        System.out.println(list);
/*
[5, 12, 20]
1
[5, 12, 20]
[20, 12, 5]
[5, 20, 12]

list和数组之间的相互转换

    List<Integer> list = new ArrayList<>();
    list.add(1);
    list.add(2);
//    list转数组:右边括号内Integer个数小于或等于list个数左边得到就是list个数
//        大于list个数在list个数基础上补null到该个数
    Integer[] arr = list.toArray(new Integer[0]);
    //数组需要这种方式，不能直接打印
    System.out.println(Arrays.toString(arr));
//    数组转集合
    String[] name = {"张三","李四"};
    //受限集合不能添加或删除
    List<String> list1 =  Arrays.asList(name);
    System.out.println(list1);
    //基本类型数组转的时候需要封装类
    Integer[] a = {1,2,3};
    List<Integer> list2 = Arrays.asList(a);
    // 可以用这种方式解除该限制
   // List<String> list =new ArrayList<>(Arrays.asList(s));

/*
[1, 2]
[张三, 李四]
[1, 2, 3]

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/195261.html

赞 (0)
小半的头像小半
0 0

相关推荐

极客之音——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！