java学习第十七天之ArrayList,LinkList,HashSet,TreeSet

最新推荐文章于 2021-07-29 20:33:10 发布
最新推荐文章于 2021-07-29 20:33:10 发布
阅读量401 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weiyumeizi/article/details/62429341
版权

ArrayList

package cn.myarraylist.domain;

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

/**
 * @author 韦玉梅
 *
 */
public class ArrayListTest_1 {
    /**
    * @param 定义功能，请除去ArraList集合中的重复元素
    */
    public static void main(String[] args) {
        List list= new ArrayList();
        list.add("htfgvc");
        list.add("abc");
        list.add("123");
        list.add("abc");
        System.out.println(list);

        System.out.println("----------------");
        SingleElement(list);

        System.out.println("----------------");
        SinglElement2(list);


    }



    /**
     * @param 删除重复元素
     */
    private static void SingleElement(List list) {
        for(int x=0;x<list.size()-1;x++){
            Object object= list.get(x);
            for(int y=x+1;y<list.size();y++){
                if(object.equals(list.get(y)))
                    list.remove(y);
            }
        }
        System.out.println(list);
    }
    /*
    去除重复元素方式二
    思路：
    1、最后唯一性的元素很多，可以先定义一个容器用于存储这些唯一性的元素
    2、对原有容器进行元素的获取，并到临时容器中去判断是否存在，容器本身就有这个功能，判断元素是否存在
    3、存在就不存储，不存在就存储
    4.遍历完原容器，临时容器中存储的就是唯一元素了
    */
    /**
     * @param 删除元素2
     * @return
     */
    private static void SinglElement2(List list) {
        //定义一个 临时容器
        List temp =new ArrayList();
        //遍历原容器
        for(Iterator iterator=list.iterator();iterator.hasNext();){
            Object object=(Object)iterator.next();
            //在临时容器中判断遍历元素是否存在
            if(!temp.contains(object))
//              如果不存在，就存储到临时容器中
                temp.add(object);
        }
        System.out.println(temp);
    }
    /*
    public boolean equals(Object object) {
//      判断是否相同
        if(this==object)
            return true;
        System.out.println(this+"........."+object);
        if(!(object instanceof Person)){
            throw new ClassCastException("类型错误");
        }
        Person person =(Person)object;
        return this.name.equals(person.name) && this.age==person.age;
    } */

}

package cn.myarraylist.domain;

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

/**
 * @author 韦玉梅
 *
 */
public class ArrrayListDemo {
    /**
    * @param 向ArrayList中存储自定义对象 Person（name，age）
    * 思路
    * 1、描述：Person
    * 2.定义容器对象
    * 3、将Person对象存储到集合中
    */
    public static void main(String[] args) {
//      创建ArrayList集合对象
        ArrayList array1 =new ArrayList();


//      添加Person类型的对象
        Person p1=new Person("张三",19);
        Person p2=new Person("王五",20);
        array1.add(p1);
        array1.add(p2);
        array1.add(new Person("王二",21));
        System.out.println(array1);


        System.out.println("-------------------------");
        for(Iterator iterator=array1.iterator();iterator.hasNext();){
//          iterator.next():取出的元素都有Object类型的
//          System.out.println(iterator.next());
            Person person= (Person) iterator.next();
            System.out.println(person);
            System.out.println("---------------");
            System.out.println(person.getName()+":"+person.getAge());

        }

//      取出元素

    }
}

class Person{
    private String name;
    private int age;
    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 Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    /**
     * @param name
     * @param age
     */
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }   


}

LinkList

package cn.myarraylist.domain;

import java.util.LinkedList;

/**
 * @author 韦玉梅
 *
 */
public class LinkListDemo {
    /**
    * @param args
    */
    public static void main(String[] args) {
//      创建一个链表对象
        LinkedList list=new LinkedList();

//      添加方法
        list.addFirst("123");
        list.addFirst("abc");
        list.add("dufrdhf");
        list.addFirst("sdf");


//      获取元素
        System.out.println(list.getFirst());
        System.out.println(list.getFirst());

//      删除元素
        System.out.println(list.removeFirst());

//      取出list中的所有元素
        while (!list.isEmpty()) {
            System.out.println(list.removeLast());

        }
    }    
}

package cn.myarraylist.domain;

import java.util.LinkedList;

/**
 * @author 韦玉梅
 */
public class LinkListDemo2 {
    /**
    * @param 练习
    * 请通过LinkList实现一个堆栈，或者队列数据结构
    * 堆栈：先进先出
    * 队列：先进后出
    */
    public static void main(String[] args) {
//       创建自定义的队列对象
        MyQueue queue =new MyQueue();
//      添加元素
        queue.myAdd("abc1");
        queue.myAdd("abc2");
        queue.myAdd("abc3");
        queue.myAdd("abc4");

//      获取所有元素，先进先出 
        while (!queue.isNull()) {
            System.out.println(queue.myGet());

        }
    }
}
class MyQueue{
    private LinkedList linkedList;

    public MyQueue() {
        linkedList=new LinkedList();
    }

    public void myAdd(Object object) {
//      内部使用的是linkList的方法
        linkedList.addFirst(object);
    }

    public Object myGet() {
        return linkedList.removeFirst();
    }

//  集合中是否有元素的方法
    public boolean isNull() {
        return linkedList.isEmpty();
    }


}

Student.java

/**
 * 
 */
package cn.myarraylist.domain;

import javax.print.attribute.standard.Copies;

/**
 * @author john5
 *
 */
public class Student implements Comparable{
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
    /**
     * @param name
     * @param age
     */
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
//  覆盖hasCode()，根据对象的特点定义哈希值
    @Override
    public int hashCode() {
//      System.out.println("123");
//      return this.age;
        return name.hashCode();
    }

    @Override
//  需要定义自身判断自身相同的依据，需要覆盖equals方法
    public boolean equals(Object object) {
        System.out.println(this+"\t"+object);
        if(this==object)
            return true;

        if(! (object instanceof Student)){
            throw new ClassCastException("类型错误");
        }

        Student student=(Student)object;
        if(name.equals(student.name)){
            return true ;
        }else{
            if(this.age == student.age){
                return true ;
            }
        }
        return false ;
    }
    @Override
    /*
    学生就具备了比较的功能，该功能是自然排序使用的方法
    自然排序就年龄的升序排序为主
    */
    public int compareTo(Object o) {
        /*Student student=(Student) o;
        if(this.age>student.age)
            return 1;
        if(this.age<student.age)
            return -1;
        return 0;*/

        /*return 1;*/
        /*
        既然是同姓名同年龄是同一个人，视为重复元素，要判断的要素有两个
        既然是按照年龄进行排序，所以先判断年龄，再判断姓名*/
        Student student=(Student) o;
        int temp=this.age-student.age;
        return temp==0?this.name.compareTo(student.name):temp;
    }
}

HashSet

/**
 * 
 */
package cn.myarraylist.domain;

import javax.print.attribute.standard.Copies;

/**
 * @author john5
 *
 */
public class Student implements Comparable{
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
    /**
     * @param name
     * @param age
     */
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
//  覆盖hasCode()，根据对象的特点定义哈希值
    @Override
    public int hashCode() {
//      System.out.println("123");
//      return this.age;
        return name.hashCode();
    }

    @Override
//  需要定义自身判断自身相同的依据，需要覆盖equals方法
    public boolean equals(Object object) {
        System.out.println(this+"\t"+object);
        if(this==object)
            return true;

        if(! (object instanceof Student)){
            throw new ClassCastException("类型错误");
        }

        Student student=(Student)object;
        if(name.equals(student.name)){
            return true ;
        }else{
            if(this.age == student.age){
                return true ;
            }
        }
        return false ;
    }
    @Override
    /*
    学生就具备了比较的功能，该功能是自然排序使用的方法
    自然排序就年龄的升序排序为主
    */
    public int compareTo(Object o) {
        /*Student student=(Student) o;
        if(this.age>student.age)
            return 1;
        if(this.age<student.age)
            return -1;
        return 0;*/

        /*return 1;*/
        /*
        既然是同姓名同年龄是同一个人，视为重复元素，要判断的要素有两个
        既然是按照年龄进行排序，所以先判断年龄，再判断姓名*/
        Student student=(Student) o;
        int temp=this.age-student.age;
        return temp==0?this.name.compareTo(student.name):temp;
    }
}

package cn.myarraylist.domain;

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

import org.omg.CORBA.PRIVATE_MEMBER;

/**
 * @author 韦玉梅
 *
 */
public class HashSetDemo2 {
    /**
    *1、不允许存储重复元素，因为会发生查找的不确定性
    *2、不保证存入和取出的顺序一致
    *3、比数组的查询效率高
    *4、用于存储元素和哈希值对应关系的容器称之为哈希表，冲突后，需要对元素进行进一步的判断，判断的是元素的内容，equals。
    *当哈希算法算出的两个元素的值相同时，称为哈希冲突
    *
    *哈希表在判断元素是否相同，依据hasCode()方法，如果哈希重复（哈希值相同），
    *再判断元素的equals方法，如果equals返回true,不存，返回false，存储！
    *
    * @param 练习：往hashset中存储学生对象（姓名 年龄）。 同姓名，同年龄视为同一人，不存 
    * 1、描述学生
    * 2、定义容器
    * 3、将学生对象存储到容器
    * 
    * 发现存储了同姓名同年龄的学生是可以的
    * 原因是每一次存储学生对象，都想调用hasCode（）获取哈希值
    * 但是调用的Object类中的hassCode，所以不同的对象，哈希值也不同
    * 这就是同姓名同年龄存入的原因
    * 
    * 解决：
    * 需要根据学生对象自身的特点来定义哈希值
    * 所以就需要覆盖hasCode方法
    * 
    */
    public static void main(String[] args) {
//      创建容器对象
        Set<Student> set =new HashSet<>();

//      创建学生对象
        set.add(new Student("大黑",1));
        set.add(new Student("Blue",5));
        set.add(new Student("Bubble",1));
        set.add(new Student("Blue",25));
        set.add(new Student("Blue",5));

//      获取所有的学生
        for(Iterator iterator=set.iterator();iterator.hasNext();){
            Student student=(Student) iterator.next();
            System.out.println(student.getName()+"\t"+student.getAge());
        }
    }
}

TreeSet

package cn.myarraylist.domain;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

/**
 * @author 韦玉梅
 *
 */
public class TreeSetDemo {
    /**
    * @param TreeSet
    * |--二叉树数据结构。TreeSet可以对元素进行排序 。不同步的
    * 排序方式：需要元素具备比较功能，所以元素需要实现Comparab;e接口。覆盖CompareTo方法
    * 如何保证元素的唯一性？
    * 参考的就是比较方法的返回值是否是0，是，就是重复元素，不存。
    * 排序方式：需要元素具备背胶功能，所以元素需要实现Comparable接口，覆盖CompareTo方法
    */
    public static void main(String[] args) {
        /*
        初始化TreeSet集合明确一个比较器，实现Comparator接口，覆盖compare方法，将Comparator接口的对象，
        作为参数传递给TreeSet集合的构造函数
        比较器更为灵活，自然排序通常作为元素的默认排序
        */
        Set set =new TreeSet(new ComparatorByName());//会自动排序 比较器
/*//        创建容器对象
        Set set =new TreeSet();*/

/*//        创建对象
        set.add("abc1");
        set.add("eferf");
        set.add("1bc3");
        set.add("abc4");*/
//      创建学生对象
        set.add(new Student("大黑",1));//java.lang.ClassCastException:
                                        //因为学生要排序，就需要比较，而没有定义比较方法，无法完成排序
                                        //比较add方法中使用的是comparable接口中的比较方法
        set.add(new Student("Blue",5));
        set.add(new Student("Bubble",1));
        set.add(new Student("Blue",25));
        set.add(new Student("Alue",5));//CompareTo会将Alue排到Blue前面

//      获取所有的学生
        for(Iterator iterator=set.iterator();iterator.hasNext();){
//          System.out.println(iterator.next());
            Student student=(Student) iterator.next();
            System.out.println(student.getName()+"\t"+student.getAge());
        }
    }
}
MiracleBubble
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java中ArrayList 、LinkList的区别分析
09-05
在Java编程语言中，ArrayList和LinkedList都是集合框架中两种重要的列表实现，它们分别基于不同的数据结构，具有不同的特性和性能特点。以下是对这两个类的详细分析： 1. 数据结构： - ArrayList是基于动态数组...
Java中的linklist使用getLast（）方法比较时应用equal
qq_52651584的博客
03-04 319
例如泛型<Integer>返回整数类型实例，不能直接==比较
[JAVA]TreeSet,ArrayList
让勤奋成为习惯
12-18 5006
（中国大陆著名杀毒软件公司J2007年面试题） 题目：一个字符串中可能报好a~z中的多个字符，如有重复，如String data="dwsiqwksoqsmwqiswqwswqswqs"，求出现次数最多的那个字幕及次数，如有多个重复则都求出。 分析：笔者拿到看到该题后，有多种思路涌现出来，比如我们可以创建一个长度为26的数组，用来记录每个字符出现的次数，fine，类似这样的思路我想大家
java集合框架的练习之TreeSet集合与ArrayList集合的混合使用
striner的博客
11-04 1158
java集合框架的练习之TreeSet集合与ArrayList集合的混合使用 要求:在一个集合中存储无序并且重复的字符串,定义一个方法,使得该集合中的字符串保留重复并排序输出
ArrayList与LinkedList、TreeSet与HashSet、HashMap与LinkedHashMap之间的比较
wu371894545的博客
11-28 3132
前言：人类一思考,上帝就发笑 之前ArrayList与LinkedList、TreeSet与HashSet、HashMap与LinkedHashMap之间都比较茫然，下面我针对这 几个类具体类来进行比较，首先我们上一张图 在上面的比较中，我们针对相同颜色的俩者分别来进行比较 1.ArrayList与LinkedList比较 ArrayList 采用的是数组形式来保存对
java集合类，ArrayList、HashSet 、LinkedLlist
JAVA技术开发手册
11-24 377
  ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。 读写效率 HashSet读写是最慢的，因为HashSet每次add要判断hashcode，HashSet两种循环中iterator 方式不稳定，不过总是比foreach要快一点。ArrayList读写效率其次，在ArrayList中间插入或删除一个元素，要改变整个集合中该元素后面所有元素的下标位置...
Java基础加强_ArrayList_HashSet的比较及Hashcode分析
12-01
在Java编程语言中，ArrayList和HashSet是两种常用的集合类，它们各自有其特性和应用场景。在实际开发中，理解它们的差异以及如何有效地利用它们是非常重要的。本篇将深入探讨ArrayList与HashSet的区别，并分析...
java中ArrayList 、LinkList区别.doc
12-25
在Java编程语言中，ArrayList和LinkedList都是集合框架中两种重要的数据结构，它们...在实际开发中，还可以结合ArrayList和LinkedList的特性，利用Java集合框架中的其他数据结构，如HashSet或HashMap，来优化代码性能。
C# ArrayList、HashSet、HashTable、List、Dictionary的区别详解
08-25
C# ArrayList、HashSet、HashTable、List、Dictionary的区别详解 C# 中有多种集合类，每种集合类都有其特点和应用场景。了解这些集合类的区别可以帮助开发者选择合适的集合类来提高程序的性能和可读性。本文将介绍 ...
java毕业设计之ArrayList，LinkList链表接口实现源码.zip
07-17
在本Java毕业设计项目中，主要探讨了两种重要的数据结构——ArrayList和LinkedList，它们都是Java集合框架中的核心组件，属于List接口的实现类。ArrayList和LinkedList各有特点，适合不同的应用场景，理解并掌握这两...
java集合(ArrayList/Vector/LinkedList/HashSet/TreeSet/ArrayDeque/PriorityQueue/HashMap/HashTable/TreeM)
u014138443的博客
05-05 540
此图来源于：http://blog.csdn.net/u010887744/article/details/50575735 大图可以点此访问：http://img.blog.csdn.net/20160124221843905 Java 集合框架主要包括两种类型的容器，一种是集合（Collection），存储一个元素集合，另一种是图（Map），存储键/值对映射。 Collection 接口又...
Java集合-Arraylist,Linklist,Hashset,Treeset,Hashmap,Treemap区分
Wangzx的博客
04-29 799
Java集合分为三类: List :存储可以自动扩展的数组 Set :存储没有重复元素的数组 Map:存储映射关系的关联数组 List分为:Arraylist和Linkedlist -&gt; Arraylist是可以自动扩展,长度可变,动态的数组数据结构,访问元素快,插入删除慢 创建集合的对象: ArrayList &lt; Student&gt; list=new ArrayL...
关于TreeSet的排序问题
u013216420的专栏
10-30 2891
在大多数的java项目中，我们都会用到Java的集合,如 Collection和Map接口。其中用到它们最多的实现类一般要数HashSet,ArrayList,HashMap,对于TreeSet,LinkList,TreeMap这些类一般人可能会相对用得少了.其实这些实现类还是非常有用的。这里阿堂就和您一起去探个究经吧，看看它们是何方神圣! 　　　TreeSet是SortedSet接口的唯一
ArrayList 、LinkList 、HashSet 、HashMap学习记录
weixin_48439150的博客
07-29 195
我将学习到的内容和自己的一些理解写在了代码的注释里，以下贴几段代码： 一张图： Student类： public class Student { private int id; private String name; private String gender; private int age; public Student() { } public Student(int id, String name, int age, Stri.
Java ArrayList, LinkList, TreeList 区别
热门推荐
suibianshen2012的专栏
08-23 1万+
ArrayList和LinkedList在性能上各 有优缺点，都有各自所适用的地方，总的说来可以描述如下：           1．ArrayList是基于动态数组的数据结构，而LinkedList是基于链表的数据结构。 　　2．对ArrayList和LinkedList而言，在列表末尾增加一个元素所花的开销都是固定的。对 ArrayList而言，主要是在内部数组中增加一项
ArrayList、LinkedList、HashSet、TreeSet间的区别和联系。
小白的进化史
02-27 3379
Collection            |--List:元素是有序的，元素可以重复。因为该集合体系有索引。                      |--ArrayList:底层的数据结构使用的是有序数组结构。特点：查询速度很快O(1)。但是增删稍慢O(n)。线程不同步。                      |--LinkedList:底层使用的链表数据结构。特点：增删速度很快O
深入理解 ArrayList、LinkedList、HashSet 等 Java 容器
HappyFeet的博客
05-10 5456
本文主要从 Java 源码深入学习 java.util 包中容器部分的底层代码实现
udp分片报文pcap文件
最新发布
07-18
udp分片报文pcap文件：64kudp大包分成每片658字节总计100片
计算机教学导案.doc
07-18
计算机
Java集合框架学习：ArrayList, HashSet, HashMap与迭代器
"这篇资料主要关注的是Java编程中Collection集合框架的学习目标和相关知识点，包括ArrayList、HashSet、HashMap、Iterator以及Properties的使用。此外，还涉及到了数据结构的基础概念，如顺序存储、链式存储、栈和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值