java基础复习（八）集合（迭代器、Arraylist、Vector、LinkedList、HashSet，TreeSet）

最新推荐文章于 2022-01-13 15:20:12 发布
最新推荐文章于 2022-01-13 15:20:12 发布
阅读量115 收藏
点赞数 2
分类专栏： Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39446291/article/details/97899270
版权

Java基础复习（八）

集合

1.区分数组和集合

  1. 数组：可以存储不同类型的多个数据,数据类型可以是简单数据类型也可以引用数据类型

    缺点:创建的是一个定值,只能存储固定长度的数据,一旦存满了,就不能再继续存储.

  2. 集合：可以存储不同类型的多个数据,但是只能存储引用数据类型.

    • 缺点:只能存储引用数据类型
    • 优点:存储空间会随着存储数据的增大而增大,所以可以更加合理的利用内存空间,方法很多,方便我们实现功能.

2.分类

   Collection:---接口
 * 		>List---接口
 * 			>>ArrayList--类
 * 			>>Vector  ---类
 * 			>>LinkedList--类
 		>Set---接口
 * 			>>HashSet--类
 * 			>>TreeSet--类
   Map:--接口
 * 		>HashMap--类
 * 		>TreeMap--类
 *
1.Collection
//Collection中定义是整个集合体系最共性的方法:
		Collection collection = new ArrayList<>();
		//1.添加：
		//boolean add(Object o) 
		collection.add("java");
		collection.add("python");
		System.out.println(collection);//重写了toString()
		//boolean addAll(Collection<? extends E> c)  一次添加多个元素
		Collection collection1 = new ArrayList<>();
		collection1.add("BigData");
		collection1.add("hadoop");
		collection.addAll(collection1);
		System.out.println(collection);
		//2.删除:
	    //boolean remove(Object o)  
	    //boolean removeAll(Collection<?> c)
	    //void clear()  clear != null
		//collection.remove("java");
		//collection.clear();
		System.out.println(collection);
		//3.判断:
		//boolean contains(Object o) 
		System.out.println(collection.contains("java"));
		//boolean containsAll(Collection<?> c)  在判断当前集合是否包含子集合中的元素时,必须包含所有的元素才会返回true
		
		collection.remove("BigData");
		System.out.println("haha:"+collection.containsAll(collection1));
		//boolean isEmpty() //判断集合是否为空   空 != null
		System.out.println(collection.isEmpty());
		//boolean equals(Object o) 
		//4.获取：
		//Iterator<E> iterator() //获取集合中的对象
		test(collection);
迭代器

原理：开始指针指向第一个位置,使用hasnext方法判断,返回true,再使用next方法获取当前的值,并将指针后移一个位置,依次进行,直到指针指向了集合的末尾,再次调用hasnext方法,返回false,结束遍历.

List和Set
  1. List:存储的数据是有序的(元素的存储顺序与添加元素的顺序一致),可以重复的.
    public class Demo2 {
	public static void main(String[] args) {
		//* List：特有方法，可以操作下标
		List list = new ArrayList<>();
		//1.增：
		//void add(int index, E element) 
		//boolean addAll(int index, Collection<? extends E> c) 
		list.add("java");
		list.add("html");
		list.add(1, "hadoop");
		System.out.println(list);
		//2.删	
		//E remove(int index) 
		//System.out.println(list.remove(0));
		//3.改
	    //E set(int index, E element)
		System.out.println(list.set(0, "haha"));
		//4.查
	     //ListIterator<E> listIterator() 
		test(list);
	     //返回此列表元素的列表迭代器（按适当顺序）。 
	     //ListIterator<E> listIterator(int index) 
	     //List<E> subList(int fromIndex, int toIndex)   左闭右开
		List list2 = list.subList(1, 2);
		System.out.println(list2);
	     //E get(int index) 
		 System.out.println(list.get(0));
		 System.out.println(list);
		//5.删除全部对象
		 list.clear();
	}
	//4.查
    //ListIterator<E> listIterator() 
	public static void test(List list) {
		//先获取迭代器对象
		ListIterator listIterator = list.listIterator();
		//从左到右
		while (listIterator.hasNext()) {
			String object = (String) listIterator.next();
			System.out.println("从左到右:"+object);
		}
		
		//从右到左
		while (listIterator.hasPrevious()) {
			String object = (String)listIterator.previous();
			System.out.println("从右到左:"+object);
		}
		
		//内部有add,set,remove方法,可以直接对当前位置的元素进行操作
		//从左到右
		while (listIterator.hasNext()) {
			String object = (String) listIterator.next();
			if (object.equals("haha")) {
				//在使用迭代器期间,使用list的删除方法直接删除元素,有可能发生错误,所以不要这样做
				//list.remove(object);
				//使用迭代器自带的remove方法
				//用迭代器提供的方法,注意:remove,add,set不要同时使用
				listIterator.remove();
			}
			
			System.out.println("从左到右:"+object);
		}
	}
}

    1. Arraylist:底层的数据结构是数组,线程不安全的.特点:查找速度快,添加删除速度慢

    2. Vector：底层的数据结构是数组,线程安全的.特点:查找速度快,添加删除速度慢

      五种遍历方式

      import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;
import java.util.function.Consumer;
public class VetcorString {
 
	public static void main(String[] args) {
		Vector<String>  t=new Vector<String>();
		t.add("F");
		t.add("o");
		t.add("r");
		t.add("e");
		t.add("v");	
		t.add("e");
		t.add("r");
		//第一种
		for (String string : t) {
			System.err.print(string);
		}
		//第二种
		t.forEach(new Consumer<String>() {
			@Override
			public void accept(String t) {
				// TODO Auto-generated method stub
				System.out.print(t);	
			}
		});
		//第三种
		for (int i = 0; i < t.size(); i++) {
			System.out.print(t.get(i));	
		}
		//第四种
		Iterator<String> it = t.iterator();
		while (it.hasNext()) {
			String string = (String) it.next();
			System.err.print(string);
		}
		//第五种
		Enumeration<String> enume = t.elements();
        while(enume.hasMoreElements()){
            System.out.print(enume.nextElement().toString());
        }
	}
}

    3. LinkedList：底层是链表,线程不安全的.特点:查找速度慢,添加删除速度快.

      public class Demo4 {
	public static void main(String[] args) {
//		LindedList
//		特有的方法：
		LinkedList linkedList = new LinkedList<>();
//		addFirst()//始终在首位添加
//		addLast()//始终在末尾添加
		linkedList.addFirst("java");
		linkedList.addLast("html");
		linkedList.add("hadoop");
		linkedList.add(1, "spark");
		linkedList.addFirst("BigData");
		System.out.println(linkedList);
//		getFirst()//获取的对象不存在会发生异常
//		getLast()
		linkedList.clear();
		
		//String value =  (String)linkedList.getFirst();//NoSuchElementException  没有这个元素异常
		//System.out.println(value);
//		removeFirst()//删除的对象不存在会发生异常
//		removeLast()

//		从jdk1.6开始出现以下方法
//		offerFirst()
//		offerLast()

//		peekFirst()//获取的对象不存在会返回null
//		peekLast()
		System.out.println(linkedList.peekFirst());
//		pollFirst()//删除的对象不存在会返回null
//		pollLast()

	}
}

    使用list存自定义的类对象并去重

    package Collection;

import java.util.ArrayList;
import java.util.ListIterator;

class Person{
    String name;
    int age;
    public Person(){}

    public Person(String name, int age) {
        this.name = name;
        this.age = 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;
    }

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

    //重写equals函数，自己制定比较规则:根据年龄和姓名比较
    @Override
    public boolean equals(Object obj) {
        if(!(obj instanceof Person))
        {
            throw new ClassCastException("当前的对象不是Person类型的");
        }
        Person person = (Person)obj;
        return this.name.equals(person.name) && this.age==person.age;
    }
}

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

        ArrayList list = new ArrayList();
        list.add(new Person("bingbing",18));
        list.add(new Person("chenchen",98));
        list.add(new Person("hanghang",108));
        list.add(new Person("zhangsan",28));
        list.add(new Person("bingbing",18));
        System.out.println(list);
        ArrayList list1 = new ArrayList();
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext())
        {
            Person object = (Person) listIterator.next();
            if(!list1.contains(object))
            {
                list1.add(object);
            }
        }
        System.out.println("去重后的结果:"+list1);


    }
}
  2. Set，存储的数据是无序的,不可以重复

    1. HashSet:底层是哈希表,线程不安全的

    2. TreeSet:底层是二叉树,线程不安全的

      • HashSet：

      • 原理:是通过调用元素的hashCode和equals方法实现去重,首先调hashCode方法,拿到当前对象的哈希码值,去让两个对象的哈希码值进行比较,如果不同,直接认为是两个对象,不再去调equals,如果相同,再继续调用equals方法,返回true认为是一个对象,返回false认为是两个对象

      • //* 实例:使用HashSet实现Person对象的存储
		// * 比较规则自己指定:按照年龄和姓名比,相同认为是一个人
		//* 分析:要重写hashCode和equals方法
public class Demo7 {
	public static void main(String[] args) {
		Set set = new HashSet<>();
		//说明Set本身的add方法内部实现的去重功能,默认调用的是元素的hashCode和equals方法
		//String类已经默认重写了hashCode和equals方法
		set.add("java");
		set.add("hadoop");
		set.add("spark");
		set.add("HDFS");
		set.add("HDFS");
		set.add("Mapreduce");
		System.out.println("result1:"+set);
		
		Set set1 = new HashSet<>();
	
		set1.add(new Person1("bingbing",18));
		set1.add(new Person1("zhangsan",28));
		set1.add(new Person1("chenchen",98));
		set1.add(new Person1("bingbing",18));
		System.out.println(set1);
	}
}

class Person1{
	String name;
	int age;
	public Person1() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Person1(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person1 [name=" + name + ", age=" + age + "]";
	}
	//重写hashCode方法
	@Override
	public int hashCode() {
		return name.hashCode()+age*1000;
	}
	//重写equals方法
	@Override
	public boolean equals(Object obj) {
		//自己制定比较规则:根据年龄和姓名比较
		//容错处理
		if (!(obj instanceof Person1)) {
			throw new ClassCastException("当前的对象不是Person1类型的");
		}
		
		//向下转型
		Person1 person = (Person1)obj;
		return this.name.equals(person.name)  && this.age==person.age;
	}
	
}

      • TreeSet

      • 可以实现排序和去重。（自然排序和人工排序）

      • 人工排序的优先级高于默认排序

        第一种（实现Comparable接口重写compareTo方法，自然排序）

      • /*第一种（实现Comparable接口的compareTo方法）
实例:在TreeSet中存入Person1类的对象
 *并按照年龄和姓名实现排序,去重
 *分析:需要实现Comparable接口的compareTo方法
 * 
 */
public class Demo8 {
	public static void main(String[] args) {
		Set set = new TreeSet<>();
	   	 /*
	   	  * TreeSet的add方法实现的排序,去重.通过调用元素的compareTo方法
	   	  * String类已经实现了Comparable接口
	   	  */
		set.add("java");
		set.add("hadoop");
		set.add("spark");
		set.add("HDFS");
		set.add("HDFS");
		set.add("Mapreduce");
		System.out.println("result1:"+set);
		
		//没有实现Compareble接口的对象不能当做TreeSet的元素,否则报异常ClassCastException
		Set set1 = new TreeSet<>();
		
		set1.add(new Person2("bingbing",18));
		set1.add(new Person2("zhangsan",28));
		set1.add(new Person2("chenchen",98));
		set1.add(new Person2("bingbing",18));
		System.out.println(set1);
	}
}

class Person2 implements Comparable{
	String name;
	int age;
	public Person2() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Person2(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person2 [name=" + name + ", age=" + age + "]";
	}
	@Override
	public int compareTo(Object o) {
		//根据自己制定的规则比较
		//根据年龄和姓名比较
		
		//容错处理
		if (!(o instanceof Person2)) {
			throw new ClassCastException("类型转换错误");
		}
		//向下转型
		Person2 person2 = (Person2)o;
		//先比姓名
		int num = this.name.compareTo(person2.name);
		//再按照年龄比
		return num==0?this.age-person2.age:num;
	}	
}

        使用实现了Comparator接口的compare()方法的比较器对象进行比较（人工排序）

      /*
将人存入TreeSet,通过Comparator实现Person2的排序和比较
 *规则:只要姓名和年龄相同认为是一个人
 */
package Collection;

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

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

            Set set = new TreeSet<String>();
            set.add("java");
            set.add("hadoop");
            set.add("spark");
            set.add("HDFS");
            set.add("HDFS");
            set.add("Mapreduce");
            System.out.println(set);

            TreeSet treeSet = new TreeSet();

            treeSet.add(new Person2("bingbing",18));
            treeSet.add(new Person2("zhangsan",28));
            treeSet.add(new Person2("chenchen",98));
            treeSet.add(new Person2("bingbing",18));
            System.out.println(treeSet);
    }
}

class Person3 implements Comparator{
    String name;
    int age;
    public Person3() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Person3(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person2 [name=" + name + ", age=" + age + "]";
    }

    @Override
    public int compare(Object o1, Object o2) {
        if(!(o1 instanceof Person3))
        {
            throw new ClassCastException("error");
        }
        if(!(o2 instanceof Person3))
        {
            throw new ClassCastException("error");
        }
        Person3 person1 = (Person3) o1;
        Person3 person2 = (Person3) o2;

        int num = person1.name.compareTo(person2.name);

        return num==0?person1.age-person2.age:num;

    }
}
Beacon-Fire
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Vector ArrayList LinkedList HashSet TreeSet LinkedList比较
xcylink的博客
07-03 171
第一部分 Java基础 Set 和 List都是实现了Collection接口的子接口；而Map是另一个集合接口。 List列表：有序，存储元素的顺序和取出元素的顺序一致；有索引；可以存储重复元素。 Vector：底层是数组，是可变长度的数组，长度不够时会新建数组，将原数组的元素拷贝到新数组，并将新元素添加到新数组中。Vector是同步的，也就是线程安全的。 ArrayList：底层是数组，是可...
java基础——集合ArrayList ,LinkedList
01-21
目录前言数组与集合区别集合描述集合格式方法ArrayList实例1.add(E e)2.add(int index, E element)3.addAll(Collection c)4.clear() 与 isEmpty()5.contains(Object o)6.indexOf(Object o)7.iterator()8.remove(int ...
（Java学习随堂笔记）java集合框架介绍、主要接口及常用的实现类、Arrays类、(Vector, ArrayList)、遍历Collection、Map接口及其实现
Zaza的博客
10-11 271
java集合框架介绍 为了表示和操作集合类型而规定的一种同一的体系结构 java集合框架 对外的接口：表示集合的抽象数据类型 接口的实现：指实现接口的java类，是可重用的数据结构 对集合运算的算法：是指执行算法的方法，例如在集合上进行查找和排序 集合框架接口 声明了对各种集合类型执行的一般操作 Collection接口 声明了一组操作成批对象的抽象方法 实现它的类：AbstractCollection类（抽象类） Collection接口的常用方法 查询方法： int size():返回集合对象中包含
Java基础 集合框架 共性方法 迭代器 ArrayList LinkedList Vector HashSet TreeSet
MagicTurto-BD的博客
06-14 465
———–android培训、java培训、java学习型技术博客、期待与您交流！————集合Collection接口java.util.Collection 包含许多对集合的操作方法 常用实现类：ArrayListList 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。
Java基础（21）——集合ArrayList、LinkedList、Set、HashSet、TreeSet详解
清风不渡
12-04 696
集合（二）版权声明一、List实现类1、ArrayList（1）原理（2）例子2、LinkedList（1）原理（2）特有方法二、Set1、Set（1）存储原理 版权声明 本文原创作者：清风不渡 博客地址：https://blog.csdn.net/WXKKang 一、List实现类 1、ArrayList   在实际的开发中，ArrayList是使用频率最高的一个集合实现类 （1）原理 ...
Java029—Java常用集合类概述ArrayList、LinkedList、HashSet、TreeSet、HashMap、TreeMap
weixin_45084986的博客
01-13 891
一、集合类概述 二、Collection接口 package com.dgut.test; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Collection; import java.util.Date; import java.util.Iterator; public class Test001 { public static void main(String[] args
Java 各种集合的区别ArrayList Vector LinkedList map区别
03-30
Java ArrayList Vector LinkedList map区别 各种集合的区别 写得非常详细
java 集合之实现类ArrayList和LinkedList的方法
08-29
下面小编就为大家带来一篇java 集合之实现类ArrayList和LinkedList的方法。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Java 集合类（HashSet、ArrayList、LinkedList、HashMap）.pptx
08-21
掌握List集合、Set集合、Map集合的使用以及Iterator迭代器和foreach循环的使用 了解常用的集合类 熟悉泛型的使用
Java中ArrayList和LinkedList区别
12-22
一般大家都知道ArrayList和LinkedList的大致区别： ... 　ArrayList和LinkedList是两个集合类，用于存储一系列的对象引用(references)。例如我们可以用ArrayList来存储一系列的String或者Integer。那
基于matlab实现二维小波时频图；图像；二维；时频分析；结决问题.rar
05-04
基于matlab实现二维小波时频图；图像；二维；时频分析；结决问题.rar
pentair 5800 SXT软水机说明书
05-04
pentair 5800 SXT软水机说明书
数据更新至2020年分地区6000千瓦及以上电厂发电量(合计).xls
05-05
数据来源：中国电力统计NJ-2021版
node-v10.0.0-linux-x64.tar.xz
05-04
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
各地区工伤保险基本情况(2022年).xls
05-05
数据来源：中国劳动统计NJ-2023版
数据更新至2020年分地区6000千瓦及以上电厂发电量增速(水电).xls
05-05
数据来源：中国电力统计NJ-2021版
基于HarmonyOS 4开发的一款新闻类的鸿蒙APP源代码
05-04
基于HarmonyOS 4开发的一款新闻类的鸿蒙APP源代码
（更新至2022年）城镇按行业、性别分的就业人员年龄构成.xls
最新发布
05-05
数据来源：中国人口与就业统计NJ-2023版
重庆大学图书管理系统设计与实现 毕业论文设计(51页).doc
05-04
重庆大学图书管理系统设计与实现 毕业论文设计(51页).doc
java库中的迭代器模式应用及其源码示例
06-07
1. 遍历集合类中的元素，如ArrayList、LinkedList、HashSet、TreeSet等。 2. 遍历Map中的键值对，如HashMap、TreeMap等。 3. 遍历文件中的数据，如BufferedReader等。 下面是一个简单的示例代码，演示了如何使用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值