带你入门Java的集合

java集合

java集合类存放于java.util包中，是一个用来存放对象的容器

集合只能存放对象
集合存放的是多个对象的引用，对象本身还是存放在堆内存中
集合可以存放不同类型，不限数量的数据类型

集合分类—set、list、map三种大体系

set: 无序，不可重复的集合
list: 有序，可重复的集合
map：具有映射关系的集合

在jdk5之后，增加了泛型，java集合可以记住容器中对象的数据类型

set

hashset

不能保证元素的排列顺序（位置由该值的hashcode决定）
不可重复（指的是hashcode不相同）
hashset不是线程安全的
集合元素可以存null

hashset类实现set接口，set接口继承collection接口

hashcode()方法

hashset集合判断两个元素相等的标准：两个对象通过equals()方法比较相等，并且两个对象的hashcode()方法返回值也相等。

如果两个对象通过equals()方法返回true，这两个对象的hashcode值也应该相同。

如果要set集合存相同类型的对象需使用泛型

package com.aggregate.demo;
import com.sun.corba.se.spi.ior.iortemplatelist;
import java.util.hashset;
import java.util.iterator;
public class set {
    public static void main(string[] args) {
        hashset<object> set = new hashset<>();
        set.add(1);
        set.add("a");//增加元素
        system.out.println(set);
        set.remove(1);//移除元素
        system.out.println(set);
        system.out.println(set.contains("a"));//判断集合中是否存在该元素
        set.clear();//清空集合
        system.out.println(set);
        //遍历集合
        set.add("a");
        set.add("b");
        set.add("c");
        set.add("d");
        //1.使用迭代器遍历集合
        iterator<object> iterator = set.iterator();
        while (iterator.hasnext()) {
            system.out.print(iterator.next() + "\t");
        }
        system.out.println("===============");
        //2.for each迭代集合
        for (object i : set) {
            system.out.print(i + "\t");
        }
        system.out.println("===============");
        system.out.println(set.size());//获取元素的个数
        set.add(null);
        system.out.println(set);
        //使用泛型存相同类型的元素
        hashset<string> set1 = new hashset<>();
        set1.add("123");
//      set1.add(2);
    }
}

treeset

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

treeset支持两种排序方法：自然排序和定制排序。默认情况下，treeset采用自然排序

自然排序

排序：treeset会调用集合元素的compareto(object obj)方法来比较元素之间的大小关系，然后将集合元素按升序排列

自定义类如何排序？

import java.util.comparator;
import java.util.iterator;
import java.util.treeset;
public class tree {
    public static void main(string[] args) {
        treeset<integer> treeset = new treeset<>();
        //treeset自然排序
        treeset.add(5);
        treeset.add(1);
        treeset.add(3);
        treeset.add(2);
        treeset.add(4);
        system.out.println(treeset);
        treeset.remove(3);
        system.out.println(treeset);
        system.out.println(treeset.contains(0));
        treeset.clear();
        system.out.println(treeset);
        iterator<integer> iterator = treeset.iterator();
        while (iterator.hasnext()) {
            system.out.println(iterator.next());
        }
        system.out.println("=============");
        for (integer i : treeset) {
            system.out.println(i);
        }
        person p1 = new person(23, "张三");
        person p2 = new person(25, "李四");
        person p3 = new person(12, "王五");
        person p4 = new person(5, "lucy");
        person p5 = new person(99, "hhhh");
        treeset<person> people = new treeset<>(new person());
        people.add(p1);
        people.add(p2);
        people.add(p3);
        people.add(p4);
        people.add(p5);
        for (person i : people) {
            system.out.println(i.name + "  " + i.age);
        }
    }
}
//把person对象存到treeset中并且按照年龄排序
class person implements comparator<person> {
    int age;
    string name;
    public person() {
    }
    public person(int age, string name) {
        this.age = age;
        this.name = name;
    }
    @override
    public int compare(person o1, person o2) {//年龄正序排序
        if (o1.age > o2.age) {
            return 1;
        } else if (o1.age < o2.age) {
            return -1;
        } else {
            return 0;
        }
    }
}

list

list与arraylist

list代表一个元素有序、且可重复的集合，集合中的每个元素都有其对应的顺序索引

list允许使用重复元素，可以通过索引来访问指定位置的集合元素

list默认按元素的添加顺序设置元素的索引

list集合里添加了一些根据索引来操作集合元素的方法

arraylist和vector

arraylist和vector是list接口的两个典型实现

区别：

vector是一个古老的集合，通常建议使用arraylist
arraylist是线程不安全的，而vector是线程安全的
即使为保证list集合线程安全，也不推荐使用vectormap

map

用于保存具有映射关系的数据，因此map集合里保存着两组值，一组值用于保存map里key，另外一组用于保存map里的value

map中的key和value都可以是任何引用类型的数据

map中的key不允许重复，即同一个map对象的任何两个key通过equals方法比较返回false

key和value之间存在单向一对一关系，即通过指定的key总能找到唯一的，确定的value

hashmap & hashtable

hashmap和hashtable是map接口的两个典型实现类

区别：

hashtable是一个古老的map实现类，不建议使用
hashtable是线程安全的map实现，但hashmap是线程不安全的
hashtable不允许使用null作为key和value，而hashmap可以

与hashset集合不能保证元素的顺序一样，hashtable、hashmap也不能保证其中key-value对的顺序

hashtable、hashmap判断两个key的标准是：key通过equals方法返回true，hashcode值也相等

hashta5ble相等的标准是：两个value通过equalhashmap判断两个value方法返回true

import java.util.hashmap;
import java.util.map;
import java.util.set;
public class mapdemo {
    public static void main(string[] args) {
        map<string, integer> map = new hashmap<string, integer>();
        map.put("b", 1);//添加数据
        map.put("c", 2);
        map.put("d", 3);
        system.out.println(map);
        system.out.println(map.get("d"));//根据key取值
        map.remove("c");
        system.out.println(map);//根据key键值对
        system.out.println(map.size());//map集合的长度
        system.out.println(map.containskey("a"));//判断当前的map集合是否包含指定的key
        system.out.println(map.containsvalue(10));//判断当前的map集合是否包含指定的value
//        map.clear();//清空集合
        set<string> keys = map.keyset();//可以获取map集合的key的集合
        map.values();//获取集合的所有value值
        //遍历map集合,通过map.keyset();
        for (string key : keys) {
            system.out.println("key:" + key + ", value:" + map.get(key));
        }
        //通过map.entryset();遍历集合
        set<map.entry<string, integer>> entries = map.entryset();
        for (map.entry<string, integer> entry : entries) {
            system.out.println("key:" + entry.getkey() + ", value:" + entry.getvalue());
        }
    }
}

treemap

treemap存储key-value对时，需要根据key对key-value对进行排序。treemap可以保证所有的key-value对处于有序状态

treemap的key排序

自然排序：treemap的所有的key必须实现comparable接口，而且所有的key应该是同一个类的对象，否则将会抛出classcastexception
定制排序（了解）：创建treemap时，传入一个comparator对象，该对象负责对treemap中的所有key排序。此时不需要map的key实现comparator接口

import java.util.map;
import java.util.treemap;
public class treemapdemo {
    public static void main(string[] args) {
        //treemap的自然排序是字典
        map<integer, string> treemap = new treemap<integer, string>();
        treemap.put(4, "a");
        treemap.put(3, "b");
        treemap.put(2, "c");
        treemap.put(1, "d");
        system.out.println(treemap);
        map<string, string> map = new treemap<string, string>();
        map.put("a", "a");
        map.put("c", "a");
        map.put("d", "a");
        map.put("b", "a");
        map.put("ab", "a");
        system.out.println(map);

    }
}

操作集合的工具类：collections

collections是一个操作set 、list和map等集合的工具类

collections中提供了大量方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变，对集合对象实现同步控制等方法

排序操作：

reverse(list):反转list中元素的顺序
shuffle(list):对list集合元素进行随机排序
sort(list):根据元素的自然顺序对指定list集合元素升序排序
sort(list,comparator):根据指定的comparator产生的顺序对list集合元素进行排序s
wap(list，int，int)：将指定list集合中的i处元素和j处元素进行交换

查找、替换

object max(collection):根据元素的自然顺序，返回给定集合中的最大元素

object max(collection,comparator):根据comparator指定的顺序，返回给定集合中的最大元素

object min(collection)

object min(collection,comparator)

int frequency(collection,object):返回指定集合中指定元素的出现次数

boolean replaceall(list list,object oldval,object newval):使用新值替换list对象的所有旧值

import java.util.arraylist;
import java.util.collections;
import java.util.comparator;
import java.util.list;
public class test {
    public static void main(string[] args) {
        list<string> list = new arraylist<>();
        list.add("a");
        list.add("c");
        list.add("d");
        list.add("f");
        list.add("b");
        system.out.println(list);
        collections.reverse(list);//反转list中元素的顺序
        system.out.println(list);
        collections.shuffle(list);//对list集合元素进行顺序排序
        system.out.println(list);
        collections.sort(list);//list集合字典升序排序
        system.out.println(list);
        student s1 = new student(14, "张三");
        student s2 = new student(12, "李四");
        student s3 = new student(13, "王五");
        student s4 = new student(11, "小刘");
        list<student> students = new arraylist<student>();
        students.add(s1);
        students.add(s2);
        students.add(s3);
        students.add(s4);
        for (student student : students) {
            system.out.println(student.name + "," + student.age);
        }
        collections.sort(students, new student());
        system.out.println("==========");
        for (student student : students) {
            system.out.println(student.name + "," + student.age);
        }
        collections.swap(list, 1, 3);//将指定list集合中的i处元素和j处元素进行交换
        system.out.println(list);
        system.out.println(collections.max(list));
        system.out.println(collections.min(list));
        student max = collections.max(students, new student());
        student min = collections.min(students, new student());
        system.out.println(max.name + ", " + max.age);
        system.out.println(min.name + ", " + min.age);
        system.out.println(collections.frequency(list, "a"));
        system.out.println(collections.replaceall(list, "a", "aa"));
        system.out.println(list);
    }
}
class student implements comparator<student> {
    int age;
    string name;
    public student() {
    }
    public student(int age, string name) {
        this.age = age;
        this.name = name;
    }
    @override
    //根据年龄升序排序对象
    public int compare(student o1, student o2) {
        if (o1.age > o2.age) {
            return 1;
        } else if (o1.age < o2.age) {
            return -1;
        } else {
            return 0;
        }
    }
}

同步控制

collections类中提供了多个synchronizedxxx()方法该方法可使指定集合包装成线程同步的集合；从而解决多线程并访问集合时的线程安全问题。

泛型

为什么要有泛型

集合中使用泛型时只有指定类型才可以添加到集合中，类型安全

java中的泛型，只在编译阶段有效。

泛型类

对象实例化时不指定泛型，默认为：object
泛型不同的引用不能相互赋值

public class test2 {
    public static void main(string[] args) {
        a<string> a = new a<string>();
        a.setkey("rexx");
        string s = a.getkey();
        system.out.println(s);
    }
}
class a<t> {
    private t key;
    public t getkey() {
        return key;
    }
    public void setkey(t key) {
        this.key = key;
    }
}

泛型接口

定义一个泛型接口

未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中

泛型方法

package com.aggregate.demo;
public class test3 {
    public static void main(string[] args) {
        b1<object> b1 = new b1<object>();
        b1<string> b2 = new b1<string>();
        b2 b3 = new b2();
        cc cc = new cc();
        cc.test("xxx");
        //泛型方法，在调用之前没有固定的数据类型
        //在调用时，传入的参数是什么类型，就会把泛型改成什么类型
        //也就是说，泛型方法会在调用时确定泛型具体的数据类型
        integer integer = cc.test1(2);
        boolean aboolean = cc.test1(true);
    }
}
//定义泛型接口
interface ib<t> {
    t test(t t);
}
//未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
class b1<t> implements ib<t> {
    @override
    public t test(t t) {
        return null;
    }
}
//传入实际参数
//如果实现接口时指定接口的泛型的具体数据类型
//这个类实现接口所有方法的位置都要泛型替换实际的具体数据类型
class b2 implements ib<string> {
    @override
    public string test(string s) {
        return null;
    }
}
//泛型方法
class cc {
    public void test() {
    }
    //无返回值的泛型方法
    public <t> void test(t s) {
        t t = s;
    }
    public string test1(string s) {
        return s;
    }
    //有返回值的泛型方法
    public <t> t test1(t s) {
        return s;
    }
    public void test2(string... strs) {
        for (string s : strs) {
            system.out.println(s);
        }
    }
    //形参为可变参数的泛型方法
    public <t> void test2(t... strs) {
        for (t str : strs) {
            system.out.println(str);
        }
    }

}
//带泛型的类可以在类里面定义泛型的变量
class dd<e> {
    private e e;
    //静态的泛型方法
    public static <t> void test3(t t) {
        //system.out.println(this.e);
        //在静态方法中，不能使用类定义泛型，如果要使用泛型，只能使用静态方法自己定义的泛型
        system.out.println(t);
    }
    //在类上定义的泛型，可以在普通的方法中使用
    public <t> void test(t s) {
        system.out.println(this.e);
        t t = s;
    }
}

通配符

1.有限制的通配符

(无穷小,person]只允许泛型为person及person子类的引用调用
[person,无穷大)只允许泛型为person及person父类的引用调用
只允许泛型为实现comparable接口的实现类的引用调用

枚举类

在某些情况下，一个类的对象是有限而且固定的。例如季节类，只能有4个对象。

手动实现枚举类：

private修饰构造器
属性使用private final修饰
把该类的所有实例都使用public static final来修饰

实现接口的枚举类

和普通java类一样枚举类可以实现一个或多个接口
若需要每个枚举值在调用实现的接口方法呈现出不同的行为方式，则可以让每个枚举值分别来实现该方法

public class test5 {
    public static void main(string[] args) {
        //season.spring,这段执行就是获取一个season的对象
        season spring = season.spring;
        spring.showinfo();
        season summer = season.summer;
        summer.showinfo();
        season spring1 = season.spring;
        //每次执行season.spring获得是相同的对象，枚举类中的每个枚举都是单例模式的
        system.out.println(spring.equals(spring1));
        spring1.test();
    }
}
enum season implements itest {
    spring("春", "春暖花开"),//此处相当于调用有参的私有构造
    summer("夏", "夏日炎炎"),
    autumn("秋", "秋高气爽"),
    winter("冬", "寒风凛冽");

    private final string name;
    private final string desc;
    season(string name, string desc) {
        this.name = name;
        this.desc = desc;
    }
    public void showinfo() {
        system.out.println(this.name + ":" + this.desc);
    }
    @override
    public void test() {
        system.out.println("这是实现的itest接口的test方法");
    }
}

interface itest {
    void test();
}

annotation(注解)概述

annotation其实就是代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。通过使用annotation，程序员可以在不改变原有逻辑的情况下，在源文件中嵌入一些补充信息

annotation可以像修饰符一样被使用，可用于修饰包，类，构造器，方法，成员变量，参数，局部变量的声明，这些信息被保存在annotation的name=value对中

anotation能被用来为程序元素（类，方法，成员变量等）设置元数据

基本的annotation

使用annotation时要在其前面增加@符号，并把该annotation当成一个修饰符使用。用于修饰它支持的程序元素
三个基本的annotation：
- @override:限定重写父类方法，该注释只能用于方法
- deprecated：用于表示某个程序元素（类、方法等）已过时
- @suppresswarnings:抑制编译器警告

自定义annotation

自定义新的annotation类型使用@interface关键字

annotation的成员变量在annotation定义中以无参数方法的形式来声明。其方法名和返回值定义了该成员的名字和类型

可以在定义annotation的成员变量时为其指定初始值，指定成员变量的初始值可使用default关键字

没有成员定义的annotation称为标记；包含成员变量的annotation称为元数据的annotation

import java.lang.annotation.*;
import java.util.arraylist;
import java.util.list;
public class test6 {
    public static void main(string[] args) {
        new testb().test01();
        @suppresswarnings({})
        list list = new arraylist();
    }
}
class testa {
    public void test() {
    }
}
class testb extends testa {
    @testann(id = 100, desc = "姓名")
    string name;
    @override
    public void test() {
        super.test();
    }
    @deprecated
    public void test01() {
    }
}
@target(elementtype.field)//这个注解类是给其他类的属性做注解
@retention(retentionpolicy.runtime)//定义注解的声明周期
@documented
@interface testann {
    public int id() default 0;
    public string desc() default "";
}

总结

本篇文章就到这里了，希望能给您带来帮助，也希望您能够多多关注www.887551.com的更多内容！

黄山市民网：https://www.huangshanshimin.com/

目录