java学习之java高级特性----集合框架及泛型

最新推荐文章于 2022-11-14 18:57:06 发布

L看看

最新推荐文章于 2022-11-14 18:57:06 发布

阅读量397

点赞数 1

分类专栏： java 文章标签： java 高级特性集合

本文链接：https://blog.csdn.net/lk990908/article/details/97619013

版权

java 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

集合：

为存储多个对象，与对象数组不同的可变大小的容器类型的变量

集合与数组的区别：

数组	集合框架
固定长度	可变长度
只能存储本类或者子类的变量	可存储任何数据类型
无排序方法，需要自己编写算法	提供对集合元素排序的算法

集合与集合框架

集合，又称容器，它是一个对象。

集合框架：提供用于管理对象集合的接口和类

常用的集合：

对于集合的contains方法若需要判断自定义的类是否在集合中包含，需要重写该类的equals方法和hashcode方法，而要使用 System.out.println（）来输出某个类的内容而不是此对象的地址（默认继承object类的toString方法返回对象的地址）则需要重写toString方法，

例如下面这个Dog类

package Test_ArrayList;

public class Dog {
    String name;
    String variety;

    public Dog() {
    }

    public String getName() {
        return name;
    }

    @Override//重写toString方法
    public String toString() {
        return this.getName()+"  "+this.getVariety();
    }

    @Override//重写hashcode方法
    public int hashCode() {
        StringBuilder sb = new StringBuilder();
        sb.append(this.name);
        sb.append(this.variety);
        char[] charArr = sb.toString().toCharArray();
        int hash = 0;
        for(char c:charArr){
            hash = hash*131+c;
        }
        return hash;
    }

    @Override//重写equals方法
    public boolean equals(Object obj) {

        if(this==obj)
            return true;
        else if(obj instanceof Dog){
            if(((Dog)  obj).name.equals(this.name)&&((Dog) obj).variety.equals(this.variety))
                return true;
            else
                return false;
        }
        else
            return false;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getVariety() {
        return variety;
    }

    public void setVariety(String variety) {
        this.variety = variety;
    }

    public Dog(String name, String variety) {
        this.name = name;
        this.variety = variety;
    }
}

Collection， List等作为借口不能被实例化。只能通过其实现类来实例化

例如：

List list = new ArrayList（）；

List :接口，有序，可重复

ArrayList 实现类：可空可重复有序不同步（线程不安全）

底层数据结构是数组，查询快，增删慢，效率高

Vector:

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

LinkedList:

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

Set：无序不可重复

HashSet实现类可空不重复无序不同步Map顶级接口（存放键值对）

Hashmap 可空不重复无序不同步

HashTable 实现类：费控不重复无序不同步

泛型：参数化类型将对象的类型作为参数，指定到其他类或者方法上，从而保证类型的安全性和稳定性。使用时必须遵守其类型约束，是其所要求的的类型或者其子类

好处：将运行性异常转移到编译时期方便编程避免了强制转换的麻烦

分类：

接口泛型类的泛型方法的泛型

在类，接口采用泛型之后<E>表示的是形参可以用来接收类型实参

下面是测试ArrayListd和LinkedList的类：（包含for循环增强for循环Iterator迭代器的使用以及forEach的使用）

package Test_ArrayList;

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

public class test {
    public static void main(String[] args) {

        ArrayList<Dog> dogs = new ArrayList<>();
        dogs.add(new Dog("000","柯基"));
        dogs.add(new Dog("001","二哈"));
        dogs.add(new Dog("002","泰迪"));

        Iterator<Dog> it = dogs.iterator();
             while (it.hasNext()){
                 Dog d = it.next();
                 System.out.println(d.name+"   "+d.variety);
        }

        dogs.remove(1);
        System.out.println( );
        dogs.forEach(i-> System.out.println(i.name+ "   "+i.variety));
        System.out.println();
        LinkedList <Dog> dogs2 = new LinkedList<>();
        dogs2.add(new Dog("003","huan"));
        dogs2.add(new Dog("004","labu"));
        dogs2.add(new Dog("005","zw"));
        dogs2.forEach(iter-> System.out.println(iter.getName()+"  "+iter.getVariety()));

        System.out.println(dogs2.contains(new Dog("003","huan")));
    }

}

运行结果：

000 柯基

001 二哈

002 泰迪

000 柯基

002 泰迪

003 huan

004 labu

005 zw

true

下面是测试hashset的类

package Test_ArrayList;

import java.util.HashSet;
import java.util.Iterator;

public class Test_set {
    public static void main(String[] args) {
        HashSet hashSet = new HashSet();
        hashSet.add("123456");
        hashSet.add(7);
        hashSet.add(new Dog("6666","td"));

        Iterator it = hashSet.iterator();
        while (it.hasNext()){
                System.out.println(it.next());
        }
      System.out.println(hashSet.contains(new Dog("6666","td")));
        System.out.println(hashSet.contains(7));

    }
}

运行结果如下：

123456

6666 td

true

HashMap的测试类

package TesthashMap;

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

public class TestHashMap {
    public static void main(String[] args) {
        HashMap<String,String> hashMap = new HashMap<String, String>();
        hashMap.put("CN","中华人民共和国");
        hashMap.put("US","美利坚合众国");
        hashMap.put("RU","俄罗斯联邦");
        System.out.println(hashMap.size());
        System.out.println("----------Iterator迭代器遍历---------------");
       Iterator<String> iter = hashMap.keySet().iterator();
       while (iter.hasNext()){
           String key = iter.next();
           System.out.println(key+"-->"+hashMap.get(key));
       }
        System.out.println("---------------------------------------");

        System.out.println("------------------------增强for循环-------------------");

        for (String s:hashMap.keySet()
             ) {
            System.out.println(s+"--*****---->"+hashMap.get(s));
        }
        System.out.println(hashMap.containsKey("FR"));
        System.out.println(hashMap.containsKey("CN"));
        hashMap.clear();
        System.out.println(hashMap.containsKey("CN"));
    }

}

执行结果如下：

----------Iterator迭代器遍历---------------

RU-->俄罗斯联邦

CN-->中华人民共和国

US-->美利坚合众国

---------------------------------------

------------------------增强for循环-------------------

RU--*****---->俄罗斯联邦

CN--*****---->中华人民共和国

US--*****---->美利坚合众国

false

true

false

需要注意的是使用迭代器时需要使用hashmap对象的KeySet（）方法（返回值为一个集合的迭代器方法）

示例：

Iterator<String> iter = hashMap.keySet().iterator();

是否存在键或者值可用containsKey或containsValu方法。

示例代码如下：

Student类

package TesthashMap;

import java.util.Objects;

public class Student {
    String name;
    String sex;

    public Student() {
    }

    public Student(String name, String sex) {
        this.name = name;
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(name, student.name) &&
                Objects.equals(sex, student.sex);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, sex);
    }
}

测试类：

package TesthashMap;

import java.util.Collections;
import java.util.HashMap;
import java.util.Scanner;

public class TestStudnetHashMap {
    public static void main(String[] args) {
        HashMap<String,Student> hashMap = new HashMap<String, Student>();

        hashMap.put("Jack",new Student("李明","男"));
        hashMap.put("san",new Student("张三","男"));
        hashMap.put("white",new Student("zmj","女"));
        hashMap.put("king",new Student("lk0","男"));
        hashMap.put("james",new Student("詹姆斯","男"));

        Scanner input = new Scanner(System.in);
        System.out.println("输入要查询的英文名称");
        String name = input.next();
        if(hashMap.containsKey(name)){
            System.out.println(name+"对应的"+hashMap.get(name));
        }
        else System.out.println("查无此人！");

        System.out.println("键集 "+hashMap.keySet());
        System.out.println("值集 "+hashMap.values());

    }
}

执行结果如下：

输入要查询的英文名称

Jack

Jack对应的Student{name='李明', sex='男'}

键集 [san, white, king, james, Jack]

值集 [Student{name='张三', sex='男'}, Student{name='zmj', sex='女'}, Student{name='lk0', sex='男'}, Student{name='詹姆斯', sex='男'}, Student{name='李明', sex='男'}]

测试Collections提供的几个常用的静态方法排序逆置最大值最小值

package TesthashMap;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;

public class TestCollectionsFounctions {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("asd");
        arrayList.add(";lk");
        arrayList.add("qowud");
        arrayList.add("asjdas");
        arrayList.add("1");
        arrayList.add("da87d");
        arrayList.add("uteri");
        arrayList.add("sd");
        arrayList.add("sv");
        arrayList.add("a");
        System.out.println("最大值："+Collections.max(arrayList));
        System.out.println("最小值："+Collections.min(arrayList));
        System.out.println("排序前----------------");
        System.out.println(arrayList);
        Collections.sort(arrayList);
        System.out.println("排序后（升序）-----------------------");
        System.out.println(arrayList);
        System.out.println("降序--------------------------------");
        Collections.reverse(arrayList);
        System.out.println(arrayList);

    }

}

执行结果如下：

最大值：uteri

最小值：1

排序前----------------

[asd, ;lk, qowud, asjdas, 1, da87d, uteri, sd, sv, a]

排序后（升序）-----------------------

[1, ;lk, a, asd, asjdas, da87d, qowud, sd, sv, uteri]

降序--------------------------------

[uteri, sv, sd, qowud, da87d, asjdas, asd, a, ;lk, 1]

L看看

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
java学习之java高级特性----集合框架及泛型

集合：为存储多个对象，与对象数组不同的可变大小的容器类型的变量集合与数组的区别：数组集合框架固定长度可变长度只能存储本类或者子类的变量可存储任何数据类型无排序方法，需要自己编写算法提供对集合元素排序的算法 ...
复制链接

扫一扫