java之旅之集合框架

最新推荐文章于 2024-11-15 18:38:47 发布

xuchou1990

最新推荐文章于 2024-11-15 18:38:47 发布

阅读量188

点赞数

分类专栏： JAVA基础 JAVAOO 文章标签： java linkedlist 框架线程安全

本文链接：https://blog.csdn.net/xuchou1990/article/details/53612352

版权

JAVA基础同时被 2 个专栏收录

15 篇文章 0 订阅

订阅专栏

JAVAOO

3 篇文章 0 订阅

订阅专栏

框架：为了实现某一目的或功能而预先设计的一系列封装好的具有继承或实现关系的类与接口。

List–列表：

当需要做大量的查询动作的时候，使用ArrayList；当需要做大量的增加删除动作（特别是往中间增删），使用LinkedList。

面试中：ArrayList常常和Vector比较；

vector:线程较ArrayList安全，但效率比ArrayList低。
ArrayList：线程不安全，但效率高。

学生类：

package com.lovo.bean;

public class StudentBean implements Comparable<StudentBean>{

    private String name;

    private int age;

    private int score;

    public StudentBean(){

    }

    public StudentBean(String name, int age, int score) {
        super();
        this.name = name;
        this.age = age;
        this.score = score;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        if(obj instanceof StudentBean){
            StudentBean stu = (StudentBean)obj;
            if(this.name.equals(stu.getName()) && this.age == stu.getAge() &&
                    this.score == stu.getScore()){
                return true;
            }
        }

        return false;
    }

    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        int num = 0;
        if(this.name != null){
            char[] array = this.name.toCharArray();
            for(int a : array){
                num += a;
            }
        }
        num += this.age;
        num += this.score;
        return num;
    }
内部比较器：
    @Override
    public int compareTo(StudentBean stu) {
        // TODO Auto-generated method stub
        //返回的正数、负数，依赖于根据比较规则两个元素的位置之差
//      if(this.age < stu.getAge()){
//          return -1;
//      }else if(this.age > stu.getAge()){
//          return 1;   
//      }else{
//          return 0;
//      }

        if(this.score > stu.getScore()){
            return -1;
        }else if(this.score < stu.getScore()){
            return 1;
        }else{
            if(this.age > stu.getAge()){
                return 1;
            }else if(this.age < stu.getAge()){
                return -1;
            }else{
                return 0;
            }
        }
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return this.name + "     " + this.age + "     " + this.score;
    }
}

package com.lovo.test;

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

import com.lovo.bean.StudentBean;

public class TestList {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //List---列表。
        //List特点：线性。即：有序，元素的放入顺序和元素的存储顺序保持一致。
        //         表象上，List最大的特点就是有下标。

        //ArrayList就是作为一个数组的封装出现的，底层就是数组
        //LinkedList底层封装的是一个双向链表。
        //当需要做大量的查询动作的时候，使用ArrayList；
        //当需要做大量的增加删除动作（特别是往中间增删），使用LinkedList

        //面试中：ArrayList常常和Vector比较

        //泛型---用来控制集合只能操作某一种数据类型
        LinkedList<StudentBean> lst = new LinkedList<StudentBean>();
        //增
        lst.add(new StudentBean("zhang3",44,90));
        lst.add(new StudentBean("zhao4",32,76));
        lst.add(new StudentBean("lidaye",55,62));
        lst.add(new StudentBean("zhoudama",60,84));

        //求长度
        int size = lst.size();

        //修改
        lst.set(0, new StudentBean("zhang3feng",102,45));

        //删除
        lst.remove(0);

        //获取某个元素
//      StudentBean stu = (StudentBean)lst.get(1);
        StudentBean stu = lst.get(1);//加上泛型不需强转

        //遍历---将集合中的每个元素依次取出，做同样的操作
        //1、使用普通for循环进行遍历
//      for(int i = 0; i < lst.size(); i++){
//          StudentBean tmpStu = lst.get(i);
//          System.out.println(tmpStu.getName());
//      }


        //2、使用迭代器---Iterator完成遍历----是集合框架类Collection直接分支专用
        //   特点是没有下标，从头到尾走一遍
//      Iterator<StudentBean> it = lst.iterator();
//      while(it.hasNext()){
//          StudentBean tmpStu = it.next();
//          System.out.println(tmpStu.getName());
//      }

        //3、for-each循环：底层封装的就是迭代器，但语法更简单，还可以操作数组
        for(StudentBean tmpStu : lst){
            System.out.println(tmpStu.getName());
        }
        //for-each还可以操作数组
//      int[] array = {12,13,14,15,16,17};
//      for(int tmp : array){
//          tmp ++;
//          System.out.println(tmp);
//      }
    }

}

Set–集：

HashSet如何判断两个元素是否重复呢？
判断set重复元素或hashmap重复键的时候，先调用hashCode 如发现返回值是一样的，再调用equals方法比较。
只有这两个条件同时满足，Java才认为这是同一个对象
所以重写了equals方法一般也要重写hashcode方法，让equals返回true的对象，hashcode也能返回同样的整数值。

这里写图片描述

HashCode
作为键存在
判断set重复元素或hashmap重复键的时候，先调用hashCode 如发现返回值是一样的，再调用equals方法比较。
hashCode 不是在new 对象的时候绑定，而是在对象第一次调用hashCode的方法时才在缓存中绑定。
源代码：hashCode方法：public native int hashCode()；
提高判断在set集合重复元素的性能的
返回的对象哈希值并不代表物理地址，而是代表这个对象在缓存中的唯一键
每个对象的第一次调用hashCode时，才会给对象计算出hashCode值。（才赋键值）
性能优化手段

package com.lovo.test;

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

import com.lovo.bean.StudentBean;

public class TestSet {

    public static void main(String[] args) {
        //Set---集
        //Set的特点---不能放置重复元素、无序。
        //            表象上，Set没有下标

        //常用子类HashSet
        //HashSet如何判断两个元素是否重复呢？
        //1、先判断两个元素的hashcode值保持一致
        //2、调用equals方法得到两个对象比较为true
        //只有这两个条件同时满足，Java才认为这是同一个对象
        //所以重写了equals方法一般也要重写hashcode方法，让equals返回true的对象
        //hashcode也能返回同样的整数值
        HashSet set = new HashSet();
        //放入元素
        set.add("hello");
        set.add(new Date());
        StudentBean stu0 = new StudentBean("zhang3",18,80);
        set.add(stu0);
        set.add(200);
        StudentBean stu1 = new StudentBean("zhang3",18,80);
        set.add(stu1);
        //放入元素的个数
        System.out.println(set.size());
//      System.out.println(stu0.equals(stu1));
//      System.out.println(stu0.hashCode());
//      System.out.println(stu1.hashCode());

        //修改---没有修改方法
        //删除---只能根据对象进行删除，还是用的equals和hashCode来判断到底删除哪个对象
        set.remove(new StudentBean("zhang3",18,80));
        //获取某个元素---无法获取某个指定的元素


        //遍历---将集合中的每个元素依次取出，做同样的操作
        //1、不支持普通for循环，没有下标
        //2、支持迭代器
//      Iterator it = set.iterator();
//      while(it.hasNext()){
//          Object obj = it.next();
//          System.out.println(obj);
//      }
        //3、支持for-each循环
        for(Object obj : set){
            System.out.println(obj);
        }





    }

}

Map–映射：

package com.lovo.test;

import java.util.Collection;
import java.util.HashMap;
import java.util.Set;

import com.lovo.bean.StudentBean;

public class TestMap {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //Map---映射
        //Map的特点：键值对。键要求唯一，值可以重复
        //          放入元素的顺序和存储顺序无关
        //常用子类：HashMap（主要用于集合操作）、Properteis（专用于操作属性文件）
        //面试中：HashMap常常和Hashtable进行比较

        HashMap<String, StudentBean> map = new HashMap<String, StudentBean>(); 
        //增加元素
        map.put("j34001", new StudentBean("zhang3",18,80));
        map.put("j34002", new StudentBean("li4",28,85));
        map.put("j34003", new StudentBean("wang5",18,87));
        //得到长度
        System.out.println(map.size());
        //修改元素
        map.put("j34003", new StudentBean("zhao6",24,75));
        //删除元素---通过键去移除元素
        map.remove("j34003");
        //获取指定的元素对象
        StudentBean stu = map.get("j34003");

        //遍历Map
        //不能同时遍历键和值；只能分开遍历
        //遍历所有的键
        Set<String> keySet = map.keySet();//得到所有的键，装入一个Set集合中，返回给调用者
        for(String key : keySet){
            System.out.println(key);
        }
        //遍历所有的值
        Collection<StudentBean> allStus = map.values();//得到所有的值，思考为什么不返回List或其它集合类型?
        for(StudentBean tmpStu : allStus){
            System.out.println(tmpStu.getName());
        }
    }

}

collection：接口–所有集合类的接口，集合框架的核心接口。

collections：类–操作集合类的算法类。

collections 的方法：max最大；min最小；sort排序；revese反转；shuffle 混排

package com.lovo.test;

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

import com.lovo.bean.IntegerComparator;
import com.lovo.bean.StudentBean;
import com.lovo.bean.StudentComparator;

public class TestCollections {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArrayList<Integer> lst = new ArrayList<Integer>();
        lst.add(216);
        lst.add(126);
        lst.add(261);
        lst.add(262);
        lst.add(26);

//      System.out.println(Collections.max(lst));//求最大
//      System.out.println(Collections.min(lst));//求最小
//      System.out.println("===========================");
//      Collections.sort(lst,new IntegerComparator());//排序，只能操作List
//      Collections.reverse(lst);//反转
        Collections.shuffle(lst);//混排--随机打乱排序
        for(int tmp : lst){
            System.out.println(tmp);
        }



        //比较器专用例子
//      ArrayList<StudentBean> lst = new ArrayList<StudentBean>();
//      lst.add(new StudentBean("zhang3",30,74));
//      lst.add(new StudentBean("li4",22,67));
//      lst.add(new StudentBean("wang5",23,67));
//      lst.add(new StudentBean("zhao6",24,80));
//      lst.add(new StudentBean("chen7",26,56));

//      Collections.sort(lst);//自带内部比较器
//      Collections.sort(lst,new StudentComparator());//提供外部比较器
//      for(StudentBean stu : lst){
//          System.out.println(stu);
//      }


    }

}

内部比较器在上面学生类里面。

外部比较器：

package com.lovo.bean;

import java.util.Comparator;

public class StudentComparator implements Comparator<StudentBean>{

    @Override
    public int compare(StudentBean o1, StudentBean o2) {
        // TODO Auto-generated method stub
        if(o1.getScore() > o2.getScore()){
            return -1;
        }else if(o1.getScore() < o2.getScore()){
            return 1;
        }
        return 0;
    }

}