[Java视频笔记]day15

最新推荐文章于 2024-07-22 17:08:21 发布
最新推荐文章于 2024-07-22 17:08:21 发布
阅读量1k 收藏
点赞数
分类专栏： Java_视频笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sr_19930829/article/details/51313352
版权

Set : 无序，不可以元素重复。

         |--HashSet:数据结构是哈希表，线程是非同步的

保证元素唯一性的原理：判断元素的hashCode值是否相同，如果相同，还会继续判断元素的equals方法，是否为true。

         |--TreeSet:可以对Set集合中的元素进行排序。

                              底层数据结构是二叉树。

                              保证元素唯一性的依据：

                              compareTo方法 return 0;

                              TreeSet排序的第一种方式，让元素自身具备比较性，元素需要实现Comparable接口，覆盖compareTo方法，这种方式也称为元素的自然顺序，或者叫做默认                                 顺序。

                              TreeSet排序的第二种方式，当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要集合自身具备比较性。在集合初始化时就有了比较方式

import java.util.*;

class day15 
{
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet();
		ts.add("cba");
		ts.add("abcd");
		ts.add("aaa");
		ts.add("bca");

		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			sop(it.next());
		}

	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

输出：

aaa

abcd

bca

cba

 

存储自定义对象

需求：在TreeSet集合中存储自定义对象Student。按照学生的年龄进行排序。


记住：排序时，当主要条件相同时，一定要判断一下次要条件。

import java.util.*;

class Student implements Comparable//该接口强制让学生具备比较性
{
	private String name;
	private int age;
	Student(String name, int age)
	{
		this.name = name;
		this.age = age;
	}

	public int compareTo(Object obj)
	{
		if(!(obj instanceof Student))
			throw new RuntimeException("不是学生对象");
		Student s = (Student)obj;
		//System.out.println(this.name + "...compareto..."+s.name);
		if(this.age > s.age)
			return 1;
		if(this.age == s.age)
		{
			return this.name.compareTo(s.name);
		}
		return -1;
	}

	public String getName()
	{
		return name;
	}

	public int getAge()
	{
		return age;
	}
}

class day15 
{
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet();
		ts.add(new Student("lisi02", 22));
		ts.add(new Student("lisi01", 24));
		ts.add(new Student("lisi09", 52));
		ts.add(new Student("lisi08", 52));
		ts.add(new Student("lisi07", 30));
		

		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			Student stu = (Student)it.next();
			sop(stu.getName()+"...."+stu.getAge());
		}
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}


输出：

lisi02....22

lisi01....24

lisi07....30

lisi08....52

lisi09....52

 

TreeSet内部数据结构


当元素自身不具备比较性，或者具备的比较性不是所需要的，这时需要让容器自身具备比较性。就定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

当两种排序都存在时，以比较器为主。

定义一个类，实现Comparator接口，覆盖compare方法.以return 0判断元素是否相同。

//按照学生的姓名从小到大排序,姓名相同，按照年龄从小到大排序
class MyCompare implements Comparator
{
	public int compare(Object o1, Object o2)
	{
		Student s1 = (Student)o1;
		Student s2 = (Student)o2;
		int num = s1.getName().compareTo(s2.getName());
		if(num == 0)
		{
			//return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
			return s1.getAge() - s2.getAge();
		}
		return num;
	}
}

//主函数中：TreeSet ts = new TreeSet(new MyCompare());

练习：按照字符串长度排序。

字符串本身具备比较性，但是它的比较方式不是所需要的，这时就只能使用比较器。

import java.util.*;

class StrLenComparator implements Comparator
{
	public int compare(Object o1, Object o2)
	{
		String s1 = (String)o1;
		String s2 = (String)o2;
		
		int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
		if(num == 0)
			return s1.compareTo(s2);
		return num;
	}
}
class day15 
{
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet(new StrLenComparator());
		ts.add("cba");
		ts.add("abc");
		ts.add("aadfdfdfa");
		ts.add("bcddfa");

		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			sop(it.next());
		}

	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

输出：

abc

cba

bcddfa

aadfdfdfa

 

 

泛型：

JDK 1.5 版本以后出现的新特性，用于解决安全问题，是一个类型安全机制。

 

好处1：将运行时期出现的问题转移到了编译时期，方便于程序员解决问题，让运行时期问题减少，安全。

好处2：避免了强制转换的麻烦。

泛型格式：通过<>来定义要操作的数据类型。

在使用java提供的对象时，什么时候写泛型呢？

通常在集合框架中很常见，只要见到<>，就要定义泛型。

其实<>就是用来接收类型的。

 

当使用集合时，将集合众要存储的数据类型作为参数传递到<>中即可。

import java.util.*;

class day15 
{
	public static void main(String[] args) 
	{
		TreeSet<String> ts = new TreeSet<String>();
		ts.add("abc01");
		ts.add("abc02");
		ts.add("abc034");


		Iterator<String> it = ts.iterator();
		while(it.hasNext())
		{
			String s = it.next();
			System.out.println(s+" : "+s.length());
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

class LenComparator implements Comparator<String>
{
	public int compare(String o1, String o2)
	{
		int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
		//要从大到小排序的话， 把o1 和o2换一下位置就可以了
		if(num == 0)
			return o1.compareTo(o2);
		return num;
	}
}

注意在实现Comparable 接口时重写equals方法时，参数必须为Object类型，因为重写的是Object方法，否则就不是重写了。

 

泛型类：

什么时候定义泛型类？

当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展，现在定义泛型来完成扩展。

import java.util.*;

class Worker
{

}
class Student
{

}
//泛型前做法
class Tool
{
	private Object obj;

	public void setObject(Object obj)
	{
		this.obj = obj;
	}

	public Object getObject()
	{
		return obj;
	}
}
//泛型后做法，泛型类
class Utils<QQ>
{
	private QQ q;
	public void setObject(QQ q)
	{
		this.q = q;
	}
	public QQ getObject()
	{
		return q;
	}
}


class day15 
{
	public static void main(String[] args) 
	{
		Utils<Worker> u = new Utils<Worker>();
		u.setObject(new Worker());
		Worker w = u.getObject();
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

泛型方法：

泛型类定义的泛型，在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。

import java.util.*;

/*
class Demo<T>
{
	public void show(T t)
	{
		sop("show:" + t);
	}
	public void print(T t)
	{
		sop("print:" + t);
	}
}
*/

class Demo
{
	public <T> void show(T t)
	{
		System.out.println("show:" + t);
	}
	public <T> void print(T t)
	{
		System.out.println("print:" + t);
	}
}

class day15 
{
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		d.show("haha");
		d.show(new Integer(4));
		d.print("heihei");
	}
}

输出：

show:haha

show:4

print:heihei

 

特殊之处：静态方法不可以访问类上定义的泛型。如果静态方法操作的应用类型不确定，可以将泛型定义在方法上。

 

可以这样：

class Demo <T>
{
	public  void show(T t)
	{
		System.out.println("show:" + t);
	}
	public <Q> void print(Q q)
	{
		System.out.println("print:" + q);
	}
	public static <W> void method(W t)//泛型<W>要放在返回类型前面，修饰符后面
	{
		System.out.println("method:"+t);
	}
}


泛型定义在接口上。

import java.util.*;

interface Inter<T>
{
	void show(T t);
}

/*
class InterImpl implements Inter<String>
{
	public void show(String t)
	{
		System.out.println("show : "+t);
	}
}
*/
class InterImpl <T> implements Inter<T>
{
	public void show(T t)
	{
		System.out.println("show : "+t);

	}
}

class day15 
{
	public static void main(String[] args) 
	{
		//InterImpl i = new InterImpl();
		//i.show("haha");
		InterImpl<Integer> i = new InterImpl<Integer>();
		i.show(4);
	}
}


泛型限定。

?表示通配符，也可以理解为占位符。

泛型的限定：

? extends E : 可以接受E类型或者E的子类型。 上限。

? super E : 可以接收E类型或者E的父类型。   下限。

import java.util.*;

class Person
{
	private String name;
	Person(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
}

class Student extends Person
{
	Student(String name)
	{
		super(name);
	}
}

class day15 
{
	public static void main(String[] args) 
	{   /*
		ArrayList<String> al = new ArrayList<String>();
		al.add("abc1");
		al.add("abc2");
		al.add("abc3");

		ArrayList<Integer> al1 = new ArrayList<Integer>();
		al1.add(4);
		al1.add(7);
		al1.add(1);
		printColl(al);
		printColl(al1);
		*/
		ArrayList<Person> al = new ArrayList<Person>();
		al.add(new Person("abc1"));
		al.add(new Person("abc2"));
		al.add(new Person("abc3"));

		ArrayList<Student> al1 = new ArrayList<Student>();
		al1.add(new Student("abc---1"));
		al1.add(new Student("abc---2"));
		al1.add(new Student("abc---3"));
		printColl(al1);//ArrayList<Person> al = new ArrayList<Student>(); error左右
	}

	public static void printColl(ArrayList<? extends Person> al)
		//泛型限定 只能接受Person类或者其子类类型，下面有getName()方法不能
	//传入任意类型，要有个限定
	{
		Iterator<? extends Person> it = al.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next().getName());
		}
	}

	/*
	public static void printColl(ArrayList<?> al)//?是通配符，不确定的类型
	{
		Iterator<?> it = al.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}*/

    /*
	public static <T> void printColl(ArrayList<T> al)
	{
		Iterator<T> it = al.iterator();
		while(it.hasNext())
		{
			T t = it.next();//可以操作该元素
			System.out.println(it.next());
		}
	}
	*/
}

TreeSet中  

Comparator<? super E> 比较器可以使用父类型，那么不同的子类就可以同时使用这个一个比较器

import java.util.*;

class Person
{
	private String name;
	Person(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
}

class Student extends Person
{
	Student(String name)
	{
		super(name);
	}
}

class Worker extends Person
{
	Worker(String name)
	{
		super(name);
	}
}

/* 这样太麻烦
class StuComp implements Comparator<Student>
{
	public int compare(Student s1, Student s2)
	{
		return s1.getName().compareTo(s2.getName());
	}
}

class WorkerComp implements Comparator<Worker>
{
	public int compare(Worker s1, Worker s2)
	{
		return s1.getName().compareTo(s2.getName());
	}
}
*/
class Comp implements Comparator<Person>
{
	public int compare(Person p1, Person p2)
	{
		return p2.getName().compareTo(p1.getName());
		//这里面只能用父类的方法.getName()
	}
}

class day15 
{
	public static void main(String[] args) 
	{ 
		
		TreeSet<Student> ts = new TreeSet<Student>(new Comp());
		ts.add(new Student("abc03"));
		ts.add(new Student("abc02"));
		ts.add(new Student("abc08"));
		ts.add(new Student("abc06"));
		ts.add(new Student("abc01"));

		Iterator<Student> it = ts.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next().getName());
		}
       
		TreeSet<Worker> ts1 = new TreeSet<Worker>(new Comp());
		ts1.add(new Worker("abc--w--03"));
		ts1.add(new Worker("abc--w--02"));
		ts1.add(new Worker("abc--w--08"));
		ts1.add(new Worker("abc--w--06"));
		ts1.add(new Worker("abc--w--01"));

		Iterator<Worker> it1 = ts1.iterator();
		while(it1.hasNext())
		{
			System.out.println(it1.next().getName());
		}
	}
}

输出：

abc08

abc06

abc03

abc02

abc01

abc--w--08

abc--w--06

abc--w--03

abc--w--02

abc--w--01











同学少年
关注
专栏目录
java自学笔记day2
02-12
Java自学笔记Day2主要涉及了两个核心主题：二进制的使用和运算符，特别是算术运算符。在深入理解这些概念之前，首先要明白Java是一种广泛使用的后端开发语言，它构建于Apache等开源基础设施之上，因此掌握这些基础...
day2 java笔记笔记
01-12
day2 java笔记
Java学习笔记day01
最新发布
lovelyOvO的博客
07-22 1419
Groovy、Scala、 JRuby、Kotlin等都是Java平台的一部分，它们依赖于Java虚拟机，同时，Java平台也因为它们变得更加丰富多彩。随着Java以及Java社区的不断壮大，Java 也早已不再是简简单单的一门计算机语言了，它更是一个平台、一种文化、一个社区。指令,而且用0和1组成的一个一个指令,所以工程师们就要记住0和1的各种组合以及对应的指令)作为一个社区，Java拥有全世界最多的技术拥护者和开源社区支持，有数不清的论坛和资料。文件的字节流中包含的信息符合当前虚拟机的要求，并。
JAVA学习笔记DAY3——菜鸟教程Java基础
weixin_47227105的博客
06-09 1138
菜鸟教程面向对象之前的部分都走马观花看了一遍。用于突击学习和复习。
苦学Java笔记（day04）
m0_70783969的博客
04-22 1760
流程控制语句
苦学Java笔记（day08）
m0_70783969的博客
04-22 2123
面向对象
java日常笔记day01
qq_40168162的博客
05-15 228
java基本语法 java的基本语法 基本数据类型以及大小 byte<char<short<int<float<long<double bolean 数组 面向对象
苦学Java笔记（day01）
m0_70783969的博客
04-22 919
常用cmd命令、将QQ的路径保存到环境变量、下载JDK、JDK的安装目录、用cmd编译运行代码、环境变量的配置、Java的版本、JRE和JDK
Java学习笔记-day01-Java入门
c1023j的博客
06-27 807
安装->简单配置->编写案例。Java SE：用于桌面应用开发，是其他两个版本的基础。Java ME：用于嵌入式电子设备或者小型移动设备，例如微波炉、数码相机。Java EE：用于web方向的网站开发。2.3.3 Java的主要特性：面向对象、安全性、多线程、简单易用、开源、跨平台。高级语言的编译运行方式：编程、编译、运行。编译型：c/c++、解释型：python、混合型：Java。Java不是直接运行在系统中，而是运行在虚拟机中。2.3.4 JRE和JDK。
java学习笔记day1
m0_52601335的博客
02-25 607
java学习笔记day1 首先，创建一个文本文档，然后命名为“类”的名字。如：Steam.java 之后，win+R打开命令面板，输入cmd. 如图： 之后，**C:\Users\22836>**代表初始的文件路径。经过，几步操作，跳转到 java文本文档所在的路径。 java文本文档所在的路径 如图： 之后，输入javac Steam.java，编译java文本文档. 会看到 文件中，多了一个 class文档。 然后，输入java Steam,就进行 执行程序的阶段了。程序会 运作，并产生结
JAVA学习笔记day 001
xiaomiguoba7的博客
04-19 244
学习笔记
Java笔记Day_01
qq_53327161的博客
03-12 936
1.程序的使用者:只需要安装JRE即可2.程序的开发者:需要安装JDK。
day3 java 学习笔记
01-13
day3 java 笔记
day4 java笔记.md
01-19
day4 java笔记.md
java程序员笔记(day1-24)2020.zip
08-05
这份"java程序员笔记(day1-24)2020.zip"文件包含了从基础到进阶的Java学习资料，适合那些希望在IT行业开启职业生涯的新手。 首先，让我们深入了解一下Java的基础知识。在Java中，常量和变量是编程的基本元素。常量...
[Java视频笔记]day11
逆风的方向 更适合飞翔
04-29 4267
进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序，该顺序就是一个执行路径，或者叫控制单元。   线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行。   一个进程中至少有一个线程。     Java虚拟机启动的时候会有一个进程java.exe。该进程中至少有一个线程在负责Java程序的执行。而且这个线程运行的代码存在于main方法中。该线程称之为主线程。  
[Java视频笔记]day16
逆风的方向 更适合飞翔
05-04 3945
集合Map： 该集合存储键值对，一对一对往里存，而且要保证键的唯一性。 1.添加          put(Kkey, V value)          putAll(Map m)          2.删除          clear()          remove(Objectkey) 3.判断          containsValue(Objectvalue
[Java视频笔记]day23
逆风的方向 更适合飞翔
05-12 3581
网络编程   网络模型：OSI参考模型，TCP/IP参考模型 网络通讯要素：IP地址，端口号，传输协议 IP地址（对应对象 InetAddress）          网络中设备的标识          不易记忆，可用主机名          本地回环地址：127.0.0.1主机名:localhost import java.net.*; class day23 {
Java IO输入输出流 笔记
逆风的方向 更适合飞翔
04-13 3218
String s = "慕课ABC"; byte[] bytes1 = s.getBytes();//转换成字节序列用的是项目默认的编码 ，编码GBK for(byte b : bytes1) { //把字节（转换成）int以16进制的方式显示， 只显示后8位 System.out.println(Integer.toHexString(b & 0xff) + " ");
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值