20.集合

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

20.集合

比较器

比较器，其实就是在创建TreeSet集合的时候，在构造方法中指定具体的比较方式，Comparator是一个接口，

public class TreeSetDemo {

	public static void main(String[] args) {
		//按照姓名进行排序
//		Set set = new TreeSet(new ComparatorByName());
		ComparatorByName comparatorByName = new ComparatorByName();
		Set set = new TreeSet(comparatorByName);
		set.add(new Student("小一6",21));
		set.add(new Student("小一8",21));
		set.add(new Student("小一5",25));
		set.add(new Student("小一4",18));
		set.add(new Student("小一7",20));
		for (Iterator it = set.iterator(); it.hasNext();) {
			System.out.println(	it.next());
		}
	}
}
//创建比较器
class ComparatorByName extends Object implements Comparator/*比较器*/{
	@Override
	public int compare(Object o1, Object o2) {
//		1.因为要比较的是学生对象的姓名
		Student s1 = (Student)o1;
		Student s2 = (Student)o2;
//		System.out.println(s1.getName() +"====="+s2.getName());
//		2.比较主要条件
		int temp = s1.getName().compareTo(s2.getName());
		//如果主要条件相同，则比较次要条件
		return temp==0?s1.getAge()-s2.getAge():temp;
	}
	
}

ForEach

	//增强for循环
	
/*
 *  格式：
 *  	for(元素数据类型  变量：Collection或者数组){}
 * 
 * 
 * */
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("tanzhou1");
		list.add("tanzhou2");
		list.add("tanzhou3");
		list.add("tanzhou4");
		//只能遍历元素
//		注意：新的for循环必须有被遍历的目标，只能是集合或者数组
		for(Object str : list){
			System.out.println(str);
		}
		System.out.println("================");
		int[] arr = {1,2,3};
		
		for(int x=0;x<arr.length;x++){
			System.out.println(arr[x]);
		}
		System.out.println("================");
		for(int a:arr){
			System.out.println(a);
		}
		System.out.println("================");
		for (Iterator iterator = list.iterator(); iterator.hasNext();) {
			Object object = (Object) iterator.next();
			
		}
		
	}
}

泛型的使用

public static void main(String[] args) {
		
		List<String> list = new ArrayList<String>();
//		在创建集合的时候，直接在集合上明确要存储的元素的类型
//		泛型只能定义引用数据类型
		list.add("abc");
//		list.add(1);//让编写代码的时候就报错，只要不是指定类型的对象，编译器检查会报错
//		将运行时期出的问题提前转移到了编译时期，从类转换异常变成了编译失败
//		泛型
		list.add("zzz");
//		获取字符串的长度
		for (Iterator<String> it = list.iterator(); it.hasNext();) {
//			Object obj =  it.next();
//			String str = (String)obj;//java.lang.ClassCastException
//			System.out.println(str.length());//3
			String next = it.next();
		}
		/*
		  1.安全机制
		  2.将运行时期出的问题提前转移到了编译时期
		  3.泛型技术是给编译器使用的
		  4.避免了强转
		 */
		
//		Demo<Demo> d = new Demo<Demo>();
//		d.add(1);
	}
}
//class Demo<E>{//类泛型
//	
//	public void add(int x){}
//	
//}

例：

	public static void main(String[] args) {
		//想要按照字符串的长度进行排序
		Set<String> s = new TreeSet<String>(new Comparator<String>() {
			@Override
			public int compare(String s1, String s2) {
				//强转
//				String s1 = (String)o1;
//				String s2 = (String)o2;
//				字符串的长度
				int temp = s1.length() - s2.length();
				return temp==0?s1.compareTo(s2):temp;
			}
		});
		s.add("xi");
		s.add("abcd");
		s.add("zza");
		for(Iterator<String> it = s.iterator();it.hasNext();){
			String str = it.next();
			System.out.println(str);
		}
	}
	
}

例:

	public static void main(String[] args) {
//		Tool t = new Tool();
//		t.setObj("abc");
//		jdk1.5之前，为了提高工具的扩展性，用的就是Object来进行扩展，但是这种方式虽然提高了扩展，但是容易产生类转换异常
		
//		在jdk1.5之后，就有了泛型技术，在定义的时候将不确定的类型定义成参数
		
//		
//		t.setObj(1);
//		String str = (String)t.getObj();
//		System.out.println(str);
		
//		t.setObj(1);
		Tool1_6<String> t = new Tool1_6<String>();
		t.setObj("abc");
		String str = t.getObj();
		
		
		Tool1_6<Integer> t2 = new Tool1_6<Integer>();
		t2.setObj(1);
	}
}
//工具类

//泛型类
class Tool1_6<Q>{//形式参数  Tool1_6<String> t = new Tool1_6<String>(); 
	
	private Q obj;

	public Q getObj() {
		return obj;
	}

	public void setObj(Q obj) {//Object obj = "abc";
		this.obj = obj;
	}
	
}


public static void main(String[] args) {
		Util<String> s = new Util<String>();
		s.show("abc");
		Util<Integer> i = new Util<Integer>();
//		不依赖于对象的泛型来确定方法的类型
		i.print(1);
		i.show("String");
		i.show(new Exception());
	}
	
}
class Util<W>{
	//显示
//	当方法操作的类型不确定和类上的泛型一致，可以将泛型定义在方法上
//	泛型方法
//	可以是静态方法，也可以是非静态方法
	public static <Q> void show(Q q){
		System.out.println(q);
	}
	
	//打印
//	如果方法是静态的，就不可以使用类泛型，如果需要使用泛型，那么就必须要将方法设置为泛型方法
	public /*static*/ void print(W w){
		System.out.println(w);
	}
	//泛型类中不一定所有的方法都使用泛型，一般只是这个方法操作的类型在不确定的情况下，才使用范围
	public void test(String s){
		
	}

接口定义泛型

public static void main(String[] args) {
		
		InterImpl2<String> t = new InterImpl2<String>();
		t.show("abc");
		
	}
}
//想要操作对象，但是对象不知道是什么类型
interface Inter<E>{//只有在定义的时候才会写这种形式参数泛型
	//显示
	public void show(E e);
//	public void show(String e);
}
//实现类
class InterImpl implements Inter<String>{//使用的时候传递对应的泛型参数
	@Override //重写的方法
	public void show(String e) {
		
	}
	//重载方法
	public void show(Integer e) {
		
	}
}
//实现类要操作的元素类型不确定
class InterImpl2<T> implements Inter<T>{

	@Override
	public void show(T e) {
		
		
	}
	
}

泛型中问号的作用

**
 * 泛型的高级内容：
 * 	 上限
 *   下限
 *  public TreeSet(Comparator<? super E> comparator) 
 *  public TreeSet(Collection<? extends E> c) 
 *
 */
public class GenericDemo {

	
	//coco 18 工作....---->描述对象并且封装 
	//如果有很多个对象 全部都存到集合
	
	public static void main(String[] args) {
		//存储学生对象
		List<Student> list = new ArrayList<Student>();
		list.add(new Student("小明",18));
		list.add(new Student("小红",18));
		
		printList(list);
		
		//存储学生对象
		List<Student> list2 = new ArrayList<Student>();
		list2.add(new Student("小白",18));
		list2.add(new Student("小黑",18));
		
		printList(list2);
		
		Set<Student> set = new HashSet<Student>();
		set.add(new Student("小美",18));
		set.add(new Student("小王",18));
//		printList(set); 因为方法的参数需要是一个List集合，传入set报错
		printList(set);
		
		
		List<String> list3 = new ArrayList<String>();
		list3.add("小白");
		list3.add("小黑");
		printList(list3);
		
	}
	//打印不同list集合的迭代器
//	public static void printList(List<Student> list) {
//		for (Iterator<Student> it = list.iterator(); it.hasNext();) {
//			Student student = it.next();
//			System.out.println(student);
//		}
//	}
	//泛型：定义的时候就是形参 ，在使用的时候就是实参
//	通配符
	public static void printList(Collection<?> list) {//?代表的是实参
		for (Iterator<?> it = list.iterator(); it.hasNext();) {
			 
		}
	}

}
class Student  extends Person {
	
	public Student(String name, int age) {
		super(name,age);
	}
	public Student() {
		super();
	}
	
}
class Worker extends Person{
	
	
	public Worker(String name, int age) {
		super(name,age);
	}
	public Worker() {
		super();
		// TODO Auto-generated constructor stub
	}
	
	
}

泛型的上限

public class GenericDemo2 {

	public static void main(String[] args) {
		List<Student> list = new ArrayList<Student>();
		list.add(new Student("小明",18));
		list.add(new Student("小红",18));
		printList(list);
		
		
		List<Worker> list2 = new ArrayList<Worker>();
		list2.add(new Worker("小明",18));
		list2.add(new Worker("小红",18));
		printList(list2);
		
		Set<Student> set = new HashSet<Student>();
		set.add(new Student("小美",18));
		set.add(new Student("小王",18));
		printList(set);
		
	}
//	需求：除了学生就是工人
//	上限： <? extends E> ：可以接收E类型或者E的子类型 
//	下限：<? super E>:可以接收E类型或者E的父类型
	public static void printList(Collection<? extends Person> list) {
		for (Iterator<? extends Person> it = list.iterator(); it.hasNext();) {
			  Person p = it.next();
			  System.out.println(p.getName());
		}
	}
}

上限在Java中的定义

public class Person implements  Comparable<Person>{
	private String name;
	private int age;
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	@Override
	public String toString() {
		return getClass()+" [name=" + name + ", age=" + age + "]";
	}

	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}
	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 int compareTo(Person o) {
		int temp = this.age - o.age;
		return temp==0?this.name.compareTo(o.name):temp;
	}
	
}


public class GenericDemo3 {

	public static void main(String[] args) {
		Collection<Student> p = new ArrayList<Student>();
		p.add(new Student("小红1",21));
		p.add(new Student("小红2",20));
	
//		把p集合添加到set集合中
		TreeSet<Person> set = new TreeSet<Person>(p);
		set.add(new Person("小红3",19));
		//student 继承 person 里面的所有方法都可以被继承 
/*
 * 模拟
 * class TreeSet<E>{
 * 
 * 	  public TreeSet(Collection<? extends Person> c){}
 * 
 * }
 * 
 * 
 * 
 * */		
		
		for (Iterator<Person> it = set.iterator(); it.hasNext();) {
			Person person = it.next();
			System.out.println(person);
		}
	}
}

泛型的下限

public static void main(String[] args) {

		TreeSet<Student> set = new TreeSet<Student>(new ComparatorByWorkerName());
		set.add(new Student("小红1",19));
		set.add(new Student("小红3",0));
		set.add(new Student("小红2",1));
		set.add(new Student("小红4",9));
		
		
		TreeSet<Worker> set2 = new TreeSet<Worker>(new ComparatorByWorkerName());
		set2.add(new Worker("小红1",19));
		set2.add(new Worker("小红3",0));
		set2.add(new Worker("小红2",1));
		set2.add(new Worker("小红4",9));
	/*
	 * class TreeSet<E>{//Student 
	 * 
	 *   public TreeSet(Comparator<? super E > c){} //Person
	 * 
	 * }
	 * 
	 * 
	 * */	
		for (Iterator<Student> it = set.iterator(); it.hasNext();) {
			Student person = it.next();
			System.out.println(person);
		}
	}
}

//class ComparatorByName implements Comparator<Student>{
按照姓名进行排序
//	@Override
//	public int compare(Student o1, Student o2) {
//		int temp = o1.getName().compareTo(o2.getName());
//		return temp==0?o1.getAge()-o2.getAge():temp;
//	}
//	
//	
//}
//都是比较器，并且都是比较姓名。只是类型不同
// Student和Worker虽然是不同的类型，但是他们有共性，就是Person
class ComparatorByWorkerName implements Comparator<Person>{
	//按照姓名进行排序
		@Override
		public int compare(Person o1, Person o2) {//Person o1 = new Student("小红4",9)
//			Person o1 = new Worker("小红1",19);o1.getName();
			int temp = o1.getName().compareTo(o2.getName());
			return temp==0?o1.getAge()-o2.getAge():temp;
		}
		
		
	}

集合和数组的工具类

//是用操作集合的工具类，这里面方法都是静态的，直接由类名调用
	public static void main(String[] args) {
		//获取最值
//		Collection<String> c = new ArrayList<String>();
		List<String> c = new ArrayList<String>();
		c.add("abc");
		c.add("coco");
		c.add("zz");
		c.add("tanzhou");
		
		
		String max = Collections.max(c);
		System.out.println(max);
		
		String min = Collections.min(c);
		System.out.println(min);
//		对list集合进行排序
//		Collections.sort(c);
//		System.out.println(c);
//	不想按照默认的方式排序
		Collections.sort(c, new Comparator<String>() {

			@Override
			public int compare(String o1, String o2) {
				int temp = o2.length()-o1.length();
				return temp==0?o2.compareTo(o1):temp;
			}
		});
//		打印
		System.out.println(c);
	}
}

数组的工具类


/**
 * 数组的工具类
 * @author xq
 *
 *
 */
public class ArraysTool {

	public static void main(String[] args) {
		Integer[] arr = {12,55,11,8,59};
//		排序：冒泡或者选择
		
//		快速排序
		Arrays.sort(arr);//默认是从小到大排
		//遍历
//		for (int i = 0; i < arr.length; i++) {
//			System.out.println(arr[i]);
//		}
		Arrays.sort(arr,new Comparator<Integer>() {
			@Override
			public int compare(Integer o1, Integer o2) {
				//Integer在设计的时候就实现了自然排序，重写了比较方法
				return o2.compareTo(o1);
			}
		});
//		打印
		System.out.println(Arrays.toString(arr));
		
//		数组转集合？扩展
		
//		集合转数组？限制

		
	}
}
Qwesto
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
什么是抽象类？（简述）
m0_50414588的博客
04-02 6942
1. 抽象类概述 我们创建一个动物类，并且在这个类中创建动物对象，但是当你提到动物类，你并不知道我说的是什么动物，只有看到了具体的动物，你才知道这是什么动物，所以说动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物，同理我们也可以推理不同的动物，他们的行为习惯应该是不一样的，所以我们不应该在动物类中给出具体体现，而是给出一个声明即可。 抽象类定义：在 Java 中一个没有方法体的方法应该定义为抽象方法 而类中如果有抽象方法，则必须定义为抽象类 2. 抽象类的特点 抽象类
Java抽象类
m0_71673753的博客
11-29 1262
抽象类
什么是抽象类？
weixin_59898621的博客
08-29 1138
什么是抽象类： 在Java中方法隐藏具体的实现细节的类，在父类中有一些方法必须要让子类重写，那这样的方法就叫抽象方法（父类规定子类重写的方法，子类就必须重写，否则就会报错，重写的方法由父类来决定）。在父类中有一些不需要子类重写也就是说某些子类可以重写这个方法，也可以不重写这个方法，这样的方法就叫普通方法。...
Python面向对象基础（中）—Python Day8
Colorfully_lu的博客
11-03 328
重点：类的继承、父类的调用 、静态方法 难点：继承与重写、静态方法 析构方法 析构方法的概述 当一个对象被删除或者被销毁时，python解释器也会默认调用一个方法，这个方法为__del__()方法，也称为析构方法 class Animal(): def __init__(self,name): self.name=name print('__init__方法被调用') #析构方法，当对象被销毁时，python解析器会自动调用 def __del
java中抽象类的定义
plazilan的博客
08-13 2389
一、抽象类的基本概念 抽象方法，只声明而未实现的方法我们称为抽象方法，所有的抽象方法都需要用abstract关键字声明，包含抽象方法的类也需要使用abstract关键字声明，抽象类和普通类相比，区别在于抽象类带有抽象方法，抽象方法可以只声明，而不需要方法体。 代码演示： package cn.tedu.abstractx; public abstract class People{ private String name; //声明抽象方法，没有方法体，直接分号结束 public abstract
计算机后端-Java-Java核心基础-第23章 枚举类与注解 20. 集合框架涉及到的API.avi
05-22
计算机后端-Java-Java核心基础-第23章 枚举类与注解 20. 集合框架涉及到的API.avi
集合竞价.ppt
11-13
集合竞价机制 ...① 开盘集合竞价：股票上市首日开盘集合竞价的有效竞价范围为发行价的上下 20% 。 集合竞价机制是股票交易市场中的一种交易机制，旨在提高交易效率、降低交易成本、提高市场公平性和透明度。
day20(集合框架)教案.doc
12-21
java集合框架的知识总结，内含代码讲解，知识点概括，带你更好理解java集合框架。。。。像Map集合的概念，遍历方式等
集合框架练习.doc
01-14
3. 创建一个 List 集合对象，添加 20 个 30 以内的随机整数，不允许重复，并打印输出 Java 中的 List 集合可以用来存储大量数据。通过使用 Random 类可以生成随机整数，然后将其添加到 List 集合中。使用 contains ...
容器（集合）.xmind
10-19
集合思维导图，含括3个知识点，6个接口，9个常用类，20道集合相关常见问题等
Java抽象类 详解
热门推荐
wei_zhi的博客
10-05 18万+
一、抽象类的基本概念普通类是一个完善的功能类，可以直接产生实例化对象，并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容。而抽象类是指在普通类的结构里面增加抽象方法的组成部分。那么什么叫抽象方法呢？在所有的普通方法上面都会有一个“{}”，这个表示方法体，有方法体的方法一定可以被对象直接使用。而抽象方法，是指没有方法体的方法，同时抽象方法还必须使用关键字abstract做修
抽象类基本使用方法
sda_66的博客
12-01 1028
在Java中,native方法也没有方法体，这种方法不是抽象方法本地方法是由C++实现的方法，Java只负责调用，方法体实现是C++代码JVM本身就是C++实现的。
抽象类
gaohanjie123的博客
06-16 1082
一 什么是抽象类？ 类和类之间有一些共同的特征，把这些特征提取出来，形成的就是抽象类。 抽象类本身是不存在的，所以抽象类无法创建对象。 二 抽象类的特点 1.抽象类的定义规则 【修饰符列表abstract class 类名{类体}】 2. 抽象类属于引用类型 3. 抽象类是无法实例化的，无法创建对象，所以抽象类就是用来被继承的。 4. 虽然抽象类无法实例化，但是抽象类也有构造方法，该构造方法是提供给子类使用的。 5. abstract和final不能联合使用。 6. 抽象类的子类可以..
抽象类、abstract关键字
元气满满晨
08-15 4470
引入 如前面的动物类、猫类、狗类。说动物，但是不知道说的是什么动物。只有看到了具体的动物，才知道这是什么动物。所以说，动物本身不是一个具体的事物，而是一个抽象的事物。只有真正的猫、狗是具体的动物。 不同的动物的吃的东西是不一样的，所以，我们不应该在动物类给出具体的方法体现，而是给一个方法声明即可。 在Java中，一个没有方法体的方法应该定义为抽象方法（连{}都没有的，这叫空方法体。），而类中...
Java关键字之abstract（抽象类的概念和使用）
eff666的博客
08-26 2万+
1、概述 （1）只给出方法定义而不具体实现的方法被称为抽象方法，抽象方法是没有方法体的，在代码的表达上就是没有“{}”。使用 abstract 修饰符来表示抽象方法和抽象类。 （2）abstract修饰符表示所修饰的类没有完全实现，还不能实例化。如果在类的方法声明中使用abstract修饰符，表明该方法是一个抽象方法，它需要在子类实现。如果一个类包含抽象方法，则这个类也是抽象类，必须使用abst
小白必看的抽象类的简单介绍
qq_43273025的博客
07-29 287
1,抽象类与抽象方法概念 抽象类用来描述一种类型应该具备的基本特征与功能， 具体如何去完成这些行为由子类通过方法重写来完成，如: 犬科均会吼叫，但属于犬科的狼与狗其吼叫内容不同。所以犬科规定了有吼叫功能，但并不明确吼叫的细节。吼叫的细节应该由狼与狗这样的犬科子类重写吼叫的方法具体实现。 即抽象方法指只有功能声明，没有功能主体实现的方法。 具有抽象方法的类一定为抽象类。 那么犬科就可以定义为抽象类，吼叫方法为抽象方法，没有方法体。 2,抽象类&抽象方法的定义 抽象方法定义的格式： public abs
python菜鸟基础笔记（1）
qq_39132170的博客
08-12 385
一、python--解释型（开发过程中没有了编译）、交互式（提示符后直接执行代码）、面向对象的脚本语言 特点--易于学习、易于维护、易于阅读、丰富的库、可移植、可扩展（可以使用c语言完成部分代码，然后在py程序中调用）、GUI编程、可嵌入（可以嵌入到C/C++程序） 缺点：运行速度慢 主要运用领域： 云计算（openstack）、web开发、科学计算与人工智能、系统操作和维护、金融、图形GUI windows下 a、解释器运行 b、交互式运行 c、脚本编程运行 安装...
java集合知识点大全
最新发布
04-07
20. 集合框架中的内存管理和垃圾收集 以上知识点不仅仅是Java集合框架的知识点，还包括了Java语言的其他方面，例如并发处理、Lambda表达式等。了解这些知识点可以让你更好地理解和使用Java集合框架。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值