ArrayList,TreeSet

最新推荐文章于 2023-04-09 09:07:21 发布

forever428

最新推荐文章于 2023-04-09 09:07:21 发布

阅读量599

点赞数

分类专栏： JavaSE 文章标签： ArrayList TreeSet 比较器类

本文链接：https://blog.csdn.net/forever428/article/details/83065541

版权

JavaSE 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

文章目录

ArrayList

public static void main(String[] args) {
	//* List：特有方法，可以操作下标
	List list = new ArrayList<>();
	//1.增：
	//void add(int index, E element) 
	list.add("java");
	list.add(0, "python");
	list.add("html");
	list.add("java1");
	list.add("BigData");
	System.out.println(list);
	//boolean addAll(int index, Collection<? extends E> c) 

	//2.删
	//E remove(int index) 这里可以将E暂时理解成Object
    System.out.println(list.remove(0));
    System.out.println(list);
	//3.改
    //E set(int index, E element)
    System.out.println(list.set(0, "iOS"));
    System.out.println(list);
	//4.查
     //ListIterator<E> listIterator() 
     //返回此列表元素的列表迭代器（按适当顺序）。 
    test(list);
     //ListIterator<E> listIterator(int index) 
     //List<E> subList(int fromIndex, int toIndex)  包含开头不包含结尾
    List list2 = list.subList(1, 3);
    System.out.println(list2);
     //E get(int index) 
	 System.out.println(list.get(0));   
	//5.删除全部对象
	 list.clear();
}

//4.查
//ListIterator<E> listIterator() 
public static void test(List list){
	//获取迭代器对象
	ListIterator iterator = list.listIterator();
	//从左到右遍历
	while (iterator.hasNext()) {
		Object object = (Object) iterator.next();
		System.out.println("从左到右:"+object);
	}
	
	//从右到左遍历
	while (iterator.hasPrevious()) {
		Object object = iterator.previous();
		System.out.println("从右到左:"+object);
	}
	
	//注意事项:
	while (iterator.hasNext()) {
		Object object = (Object) iterator.next();
		System.out.println("从左到右:"+object);
		
		//需求:将list中的html删除
		if (object.equals("html")) {
			//在使用迭代器遍历集合期间,使用list的删除方法直接删除元素,有可能发生错误,所以不要这样做,
			//使用迭代器自带的方法进行删除
			//list.remove("html");
			//注意:在ListIterator中包含remove,set,add方法.但是注意最好不要同时使用.
			iterator.remove();
//				iterator.set(e);
//				iterator.add(e);
		}
	}
}

public static void main(String[] args) {
	//Vector:了解
	//不同点:遍历的时候使用的是枚举器
	
	//创建存值
	Vector vector = new Vector<>();
	vector.add("java1");
	vector.add("java2");
	vector.add("java3");
	vector.add("java4");
	
	System.out.println(vector);
	
	//遍历--枚举器
	//获取枚举器对象
	Enumeration enumeration = vector.elements();
	//遍历
	while (enumeration.hasMoreElements()) {
		Object object = (Object) enumeration.nextElement();
		System.out.println(object);
		
	}
}

LinkedList

public static void main(String[] args) {
	//LindedList
	LinkedList linkedList = new LinkedList<>();
	//	特有的方法：
	//
	//	addFirst()//始终在首位添加
	//	addLast()//始终在末尾添加
	linkedList.addFirst("java");
	linkedList.addLast("python");
	linkedList.add("iOS");
	linkedList.add(1, "html");
	linkedList.addFirst("BigData");
	System.out.println(linkedList);
	
	//	getFirst()//获取的对象不存在会发生异常:NoSuchElementException
	//	getLast()
	System.out.println(linkedList.getFirst());
	//	removeFirst()//删除的对象不存在会发生异常
	//	removeLast()
	System.out.println(linkedList.removeFirst());
	//	从jdk1.6开始出现以下方法
	//	offerFirst()
	//	offerLast()
	linkedList.clear();
	//	peekFirst()//获取的对象不存在会返回null
	//	peekLast()
	System.out.println(linkedList.peekFirst());
	//	pollFirst()//删除的对象不存在会返回null
	//	pollLast()
	System.out.println(linkedList.pollFirst());
}

ArrayList

实例:list特点是有序的,可以重复的
要求:使用list存储数据,但是数据不能重复—利用contains方法

public static void main(String[] args) {
	ArrayList arrayList = new ArrayList<>();
	arrayList.add("java1");//第一个元素
	arrayList.add("java2");//第二个元素
	arrayList.add("java2");//第三个元素
	arrayList.add("java3");
	arrayList.add("java4");
	arrayList.add("java5");
	
	System.out.println(arrayList);
	
	//创建一个临时的集合用于存储不重复的元素
	ArrayList arrayList1 = new ArrayList<>();
	
	//遍历元素集合
	Iterator iterator = arrayList.iterator();
	while (iterator.hasNext()) {
		Object object = (Object) iterator.next();
		//向下转型
		String string = (String)object;
		//如果新的集合中不包含当前的元素,就将当前的元素添加进去
		/*
		 * 原理:在添加新元素的时候,返回调用元素的equals方法,去比较,所有的都返回false,整体认为是false.有一次比较
		 * 返回true,整个contains的结果就是true
		 * 
		 * 添加第三个元素的过程:
		 * 第三个元素.equels("java1") = false  继续比  第三个元素.equels("java2") = true  停止比较
		 */
		if (!arrayList1.contains(string)) {
			arrayList1.add(string);
		}
	}
	
	System.out.println(arrayList1);
	
}

练习:创建一个类:狗类属性:姓名,年龄

要求:创建一个集合保存3个狗对象,第一个拉布拉多第二个:金毛第三:博美,分别根据年龄和姓名去重

public class Demo8 {
	public static void main(String[] args) {
		ArrayList list = new ArrayList<>();
		list.add(new Dog("拉布拉多", 20));
		list.add(new Dog("金毛", 20));
		list.add(new Dog("博美", 23));
		list.add(new Dog("金毛", 26));
		
		System.out.println(list);
		
		ArrayList list1 = new ArrayList<>();
		Iterator iterator = list.iterator();
		while (iterator.hasNext()) {
			Object object = (Object) iterator.next();
			if (!list1.contains(object)) {
				list1.add(object);
			}
		}
		
		System.out.println(list1);
	}
}

class Dog{
	String name;
	int age;
	public Dog(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	
	
	//:按照人的年龄和姓名比较.只要年龄和姓名一致就认为是一个人.
	public boolean equals(Object obj) {
		if (!(obj instanceof Dog)) {
			throw new ClassCastException();
		}
		
		//向下转型
		Dog person = (Dog)obj;
		//return this.age==person.age && this.name.equals(person.name);
		//根据年龄比
		//return this.age == person.age;
		//根据姓名
		return this.name.equals(person.name);
	}
}

Set:无序的,不可重复的

HashSet:底层是哈希表,线程不安全的
TreeSet:底层是二叉树,线程不安全的

HashSet实现去重的方法:是通过调用元素的hashCode和equals方法实现去重.首先会调用hashCode方法,比较两个元素的哈希码值,如果哈希码值不同直接认为是两个对象,停止比较.如果相同,再去使用equals.返回true认为是一个对象,返回false认为是两个对象.
TreeSet:实现去重和排序的方式:
1. 让实现Comparable接口,重写compareTo方法
2. 创建比较器类,让他实现Comparator重写compare方法,再将比较器对象作用于TreeSet,内部的元素会按照比较器进行比较.
总结:

hashSet只能实现去重,不能排序
对于自定义的类要想按照自己制定的规则去重,必须重写hashcode和equals方法

public class Demo9 {
	public static void main(String[] args) {
		
		HashSet set = new HashSet<>();
		/*
		 * 在add内部实现的去重的功能.默认调用字符串的hashCode和equals方法.
		 * 在String中是重写了hashCode和equals方法,所以可以保证在进行比较的时候,比较的是内容.
		 */
		set.add("java1");
		set.add("java4");
		set.add("java2");
		set.add("java5");
		set.add("java2");
		System.out.println(set);
		/*
		 * 打印结果:[java5, java4, java2, java1]
		 * 说明:实现了去重
		 */
		
		//实例:将Person1的对象存入Set,按照姓名和年龄比较
		HashSet set1 = new HashSet<>();
		set1.add(new Person1("bingbing1", 18));
		set1.add(new Person1("bingbing2", 18));
		set1.add(new Person1("bingbing3", 183));
		set1.add(new Person1("bingbing3", 183));
		set1.add(new Person1("bingbing4", 186));
		System.out.println(set1);
		/*
		 * 打印结果:[Person1 [name=bingbing4, age=186], Person1 [name=bingbing1, age=18], Person1 [name=bingbing2, age=18], Person1 [name=bingbing3, age=183]]
		 * 说明:对自定义的类实现了去重
		 */
	}
}

class Person1{
	String name;
	int age;
	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 person = (Person1)obj;
		return this.name.equals(person.name) && this.age == person.age;
	}
}

TreeSet:实现去重和排序的方式:

让元素去实现Comparable接口,重写comparo方法------默认排序
创建比较器类,让他实现Comparetor接口写compare方法,再将比较器对象作用于TreeSet,内部的元素会按照比较器进行比较.—人工排序

树的结构

二叉树

package com.qianfeng.test;

import java.util.HashSet;
import java.util.TreeSet;

public class Demo10 {
	public static void main(String[] args) {
	
		//学习第一种
		//1.让元素去实现Comparable接口,重写compareTo方法------默认排序
		TreeSet set = new TreeSet<>();
		//使用TreeSet在存储字符串的时候自动实现了排序和去重
		//因为在add方法中调用了Comparable接口的compareTo方法
		//默认是按照升序字典顺序排序
		set.add("java1");
		set.add("java4");
		set.add("java2");
		set.add("java5");
		set.add("java2");
		System.out.println(set);
		
		//实例:将Person2的对象存入TreeSet,按照姓名和年龄比较
		TreeSet set1 = new TreeSet<>();
		set1.add(new Person2("bingbing1", 18));
		set1.add(new Person2("bingbing2", 18));
		set1.add(new Person2("bingbing3", 183));
		set1.add(new Person2("bingbing3", 183));
		set1.add(new Person2("bingbing0", 17));
		System.out.println(set1);
	}
}

//自定义的类实现Comparable接口
class Person2 implements Comparable{
	String name;
	int age;
	public Person2(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person2 [name=" + name + ", age=" + age + "]";
	}
	
	@Override
	//自己制定的规则:按照年龄和姓名比较
	/*
	 *返回正数,代表前面的比后面的大
	 *返回0,代表前后相等
	 *返回负数,代表前面的比后面的小
	 */
	public int compareTo(Object o) {
		if (!(o instanceof Person2)) {
			throw new ClassCastException("类型转换错误");
		}
		
		//向下转型
		Person2 person2 = (Person2)o;
		
		//先按照年龄比较,年龄相同再去比姓名
		int num = age-person2.age;
		return num==0?name.compareTo(person2.name):num;
	}
}

创建比较器类

让他实现Comparetor接口,重写compare方法,再将比较器对象作用于TreeSet,
//内部的元素会按照比较器进行比较.—人工排序

实例:要求按照字符串的长度对字符串进行排序–从短到长
步骤1:创建比较器类实现Comparetor接口,重写compare方法
步骤2:创建比较器对象,并指定给存储元素的TreeSet
总结:对TreeSet排序有两种方式.默认排序(系统排序)和人工排序
注意:人工排序的优先级高于默认排序.

public class Demo11 {
	public static void main(String[] args) {
		//第二种
		
		//2.创建比较器对象,并指定给存储元素的TreeSet
		ComWithLength comWithLength = new ComWithLength();
		
		TreeSet set = new TreeSet<>(comWithLength);
		//使用TreeSet在存储字符串的时候自动实现了排序和去重
		
		set.add("java1111111111111");
		set.add("java422");
		set.add("java2456");
		set.add("java523535");
		set.add("java2456");
		System.out.println(set);
	}
}

//1.创建比较器类
class ComWithLength implements Comparator{
	@Override
	public int compare(Object o1, Object o2) {
		//容错处理
		if (!(o1 instanceof String)) {
			throw new ClassCastException("类型转换异常");
		}
		if (!(o2 instanceof String)) {
			throw new ClassCastException("类型转换异常");
		}
		//向下转型
		String s1 = (String)o1;
		String s2 = (String)o2;
		
		//要求按照字符串的长度对字符串进行排序--从短到长,当长度相同的时候,按照字典排序
		int num = s1.length()-s2.length();
		return num==0?s1.compareTo(s2):num;
	}
}

forever428

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
ArrayList,TreeSet

文章目录ArrayListLinkedListArrayList练习:创建一个类:狗类属性:姓名,年龄Set:无序的,不可重复的TreeSet:实现去重和排序的方式:树的结构二叉树创建比较器类ArrayListpublic static void main(String[] args) { //* List：特有方法，可以操作下标 List list = new ArrayList&...
复制链接

扫一扫