java学习--集合框架（2）

最新推荐文章于 2022-05-06 20:59:02 发布

奋斗的鱼

最新推荐文章于 2022-05-06 20:59:02 发布

阅读量543

点赞数

分类专栏： java相关

java相关专栏收录该内容

126 篇文章 0 订阅

订阅专栏

01）TreeSet

[java] view plain copy

/*
* |--Set：元素是无序（存入顺序和元素的位置不一致），元素不可以重复。
* |--HashSet：底层的数据结构是哈希表。
* HashSet是如何保证元素唯一性的呢？
* 是通过元素的两个方法，hasCode和equals来完成的。
* 如果元素的hashCode值相同，才会判断equals是否为true。
* 如果hashCode的值不同，就不会判断equals。
* |--TreeSet：可以对集合中的元素进行排序。按照ASCII码自然顺序排列。
*/
public class TreeSetDemo {//TreeSet
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args) {
method_1();
}
public static void method_1(){
TreeSet ts = new TreeSet();
ts.add("aaa");
ts.add("abb");
ts.add("aab");
ts.add("bba");
ts.add("baa");
for (Iterator<E> it = ts.iterator(); it.hasNext();){
sop("ts = " + it.next());
}
}
}

运行结果如下图所示：

02）TreeSet存储自定义对象

[java] view plain copy

/*
* 需求：
* 往TreeSet集合中存储自定义对象（学生）。
* 按照学生的年龄进行排序。
*
* 注意：排序时，当主要条件相同时，一定要往后判断次要条件。
*/
public class TreeSetDemo_2 {
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args) {
method_1();
}
public static void method_1(){
TreeSet ts = new TreeSet();
ts.add(new Student("汤姆（1）", 20));
ts.add(new Student("杰瑞（2）", 20));
ts.add(new Student("汤姆（1）", 20));
ts.add(new Student("杰瑞（2）", 20));
ts.add(new Student("汤姆（2）", 21));
ts.add(new Student("杰瑞（2）", 21));
System.out.println("-------------------------------");
for (Iterator it = ts.iterator(); it.hasNext();){
Student st = (Student)it.next();
sop(st.getName() + " 的年龄是 = " + st.GetAge());
}
}
}
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){//复写compareTo。
if (!(obj instanceof Student))
throw new RuntimeException("不是学生对象");
Student st = (Student)obj;
System.out.println(this.name + this.age + " ----比较---- " + st.name + this.age);
if (this.age > st.age)
return 1;
if (this.age == st.age && this.name.equals(st.name))
return 0;
return -1;
}
public String getName(){
return name;
}
public int GetAge(){
return age;
}
}

运行结果如下图所示：

03）二叉树

[java] view plain copy

/*
* |--Set：元素是无序（存入顺序和元素的位置不一致），元素不可以重复。
* |--HashSet：底层的数据结构是哈希表。
* HashSet是如何保证元素唯一性的呢？
* 是通过元素的两个方法，hasCode和equals来完成的。
* |--TreeSet：可以对集合中的元素进行排序。按照ASCII码自然顺序排列。
* 底层数据结构是（二叉树）。
* 保证元素唯一性的依据是：compareTo方法，return 0;
* TreeSet排序的第一种方式：让元素自身具备比较性，元素需要实现Comparable接口，覆盖compareTo方法。
* 这种方式也称为元素的自然顺序，默认顺序。
*/
public class TreeSetDemo_3 {
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args) {
method_1();
}
public static void method_1(){
TreeSet ts = new TreeSet();
ts.add(new Student_3("汤姆（1）", 20));
ts.add(new Student_3("杰瑞（2）", 20));
ts.add(new Student_3("汤姆（1）", 20));
ts.add(new Student_3("杰瑞（2）", 20));
ts.add(new Student_3("汤姆（2）", 21));
ts.add(new Student_3("杰瑞（2）", 21));
for (Iterator it = ts.iterator(); it.hasNext();){
Student_3 st = (Student_3)it.next();
sop(st.getName() + " 的年龄是 = " + st.getAge());
}
}
}
class Student_3 implements Comparable{
private String name;
private int age;
Student_3(String name, int age){
this.name = name;
this.age = age;
}
public int compareTo(Object obj){
return 1;//值大于0，所以所有的元素都将被存储。（按age值的升序排列）
// return 0;//值等于0，所以只有第一个元素被存储。
// return -1;//值大小于0，所有的元素都将被存储。（按age值的降序排列）
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
}

运行结果如下图所示：

04）实现Comparator方法排序

[java] view plain copy

/*
* /*
* |--Set：元素是无序（存入顺序和元素的位置不一致），元素不可以重复。
* |--HashSet：底层的数据结构是哈希表。
* |--TreeSet：可以对集合中的元素进行排序。按照ASCII码自然顺序排列。
* TreeSet排序的第二种方式：当元素不具备比较性或者具备的比较性不是所需要的。
* 这时就需要让集合自身具备比较性。在集合初始化时，就有了比较方式。
* 定义比较器，将比较器作为参数传递给TreeSet集合的构造函数。
*
* 当两种方式都存在时：以比较器为主。
* 定义一个类，实现Comparator接口，覆盖compare方法。
*/
public class TreeSetDemo_4 {//Comparator
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args) {
method_4();
System.out.println("--------------------");
method_5();
}
public static void method_4(){//Comparable
TreeSet ts = new TreeSet();
ts.add(new Student_4("汤姆（1）", 20));
ts.add(new Student_4("杰瑞（2）", 20));
ts.add(new Student_4("汤姆（1）", 20));
ts.add(new Student_4("杰瑞（2）", 20));
ts.add(new Student_4("汤姆（2）", 21));
ts.add(new Student_4("杰瑞（2）", 21));
for (Iterator it = ts.iterator(); it.hasNext();){
Student_4 st = (Student_4)it.next();
sop(st.getName() + " 的年龄是 = " + st.getAge());
}
}
public static void method_5(){//Comparator
TreeSet ts = new TreeSet(new MyCompare());//将比较器作为参数传递给TreeSet集合的构造函数。
ts.add(new Student_4("汤姆（1）", 20));
ts.add(new Student_4("杰瑞（2）", 20));
ts.add(new Student_4("汤姆（1）", 20));
ts.add(new Student_4("杰瑞（2）", 20));
ts.add(new Student_4("汤姆（2）", 21));
ts.add(new Student_4("杰瑞（2）", 21));
for (Iterator it = ts.iterator(); it.hasNext();){
Student_4 st = (Student_4)it.next();
sop(st.getName() + " 的年龄是 = " + st.getAge());
}
}
}
class Student_4 implements Comparable{
private String name;
private int age;
Student_4(String name, int age){
this.name = name;
this.age = age;
}
public int compareTo(Object obj){//复写compareTo。TreeSet只看结果（return），是正还是负。
if (!(obj instanceof Student_4))
throw new RuntimeException("不是学生对象");
Student_4 st = (Student_4)obj;
if (this.age > st.age)
return 1;
if (this.age == st.age)
return this.name.compareTo(st.name);
return -1;
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
}
class MyCompare implements Comparator{//定义比较器。
public int compare(Object obj1, Object obj2){
Student_4 st1 = (Student_4)obj1;
Student_4 st2 = (Student_4)obj2;
int num = st1.getName().compareTo(st2.getName());//姓名相同的元素将不存储。
if (num == 0){
return new Integer(st1.getAge()).compareTo(new Integer(st2.getAge()));
}
return num;
}
}

运行结果如下图所示：

05）TreeSet（练习）

[java] view plain copy

/*
* 练习：按照字符串长度排序。
*
* 字符串本身具备比较性，但是它的比较方式不是所需要的。
* 这时只能创建比较器。
*/
public class TreeSetTest {
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args) {
method_test();
}
public static void method_test(){
TreeSet ts = new TreeSet(new StrLenComparator());
ts.add("stre");
ts.add("hgjfgh");
ts.add("xvc");
ts.add("wgre");
ts.add("mfhfg");
for (Iterator it = ts.iterator(); it.hasNext();){
sop(it.next());
}
}
}
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;
}
}

运行结果如下图所示：

06）泛型（概述）

[java] view plain copy

/*
* 泛型：jdk1.5版本以后出现的新特性。用于解决安全隐患，是一个类型安全机制。
* 好处：
* 1：将运行时期出现的问题ClassCastException，转移到编译时期，方便于程序员发现并解决问题。安全。
* 2：避免了强制转换麻烦。
*/
public class GenericDemo {
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args) {
method_1();
System.out.println("--------------------");
method_2();
}
public static void method_1(){
ArrayList<String> al = new ArrayList<String>();
al.add("yert");
al.add("nbvwc");
al.add("q1aqed");
al.add("sgdhdfghd");
al.add("q2rqed");
al.add("fqwdfd");
// al.add(5);//传入错误的参数类型，类型转换异常：ClassCastException
for (Iterator<String> it = al.iterator(); it.hasNext();){
String s = it.next();
sop(s + " = " + s.length());
}
}
public static void method_2(){
ArrayList<Integer> al = new ArrayList<Integer>();
al.add(1);
al.add(2);
al.add(3);
al.add(3);
al.add(2);
al.add(1);
// al.add(5);//传入错误的参数类型，类型转换异常：ClassCastException
for (Iterator<Integer> it = al.iterator(); it.hasNext();){
Integer i = it.next();
sop(i);
}
}
}

运行结果如下图所示：

07）泛型（使用）

[java] view plain copy

/*
* 泛型格式：通过<>来定义要操作的引用数据类型。
* 在使用Java提供的对象时，什么时候使用泛型呢？
* 通常在集合框架中很常见，只要剑道<>就要定义泛型。
* 其实<>就是用来接收类型的：当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
*/
public class GenericDemo_2 {
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args) {
method_2();
}
public static void method_2(){
TreeSet<String> ts = new TreeSet<String>(new LenComparator());
ts.add("aa2a");
ts.add("abbafd");
ts.add("aabva");
ts.add("aabva");//false
ts.add("bwebavc");
ts.add("weqbaa");
for (Iterator<String> it = ts.iterator(); it.hasNext();){
String s = it.next();
sop(s + " = " + s.length());
}
}
}
class LenComparator implements Comparator<String>{
public int compare(String o1, String o2) {
int num = new Integer(o2.length()).compareTo(new Integer(o1.length()));
if (num == 0)
return o2.compareTo(o1);
return num;
}
}

运行结果如下图所示：

08）泛型（类）

[java] view plain copy

/*
* 定义泛型类。
* 当类中要操作的（引用数据类型）不确定的时候用泛型类。
* 早期是通过定义Object来完成扩展的，现在通过定义泛型来完成扩展。
*/
public class GenericClassDemo {
public static void main(String[] args) {
Utlis<Worker> tls = new Utlis<Worker>();
tls.setWork(new Worker());
Worker w = tls.getWork();
}
}
class Worker{}
class Teacher{}
class Utlis<Job>{//泛型类
private Job j;
public void setWork(Job j){
this.j = j;
}
public Job getWork(){
return j;
}
}

09）类、方法（泛型）

[java] view plain copy

/*
* 泛型类（Method_1<D>）定义的泛型，在整个类中有效，如果被方法使用，那么当泛型类的对象明确要操作的具体类型后，所有要操作的类型都将固定。
*
* 为了让不同的方法可以操作不同类型，而且类型还不确定。
* 那么可以将泛型定义在方法上。（Method_2）
*/
public class GenericMethodDemo {
public static void main(String[] args) {
method_1();
System.out.println("----------------------");
method_2();
}
public static void method_1(){//使用泛型类。
Method_1<String> m1 = new Method_1<String>();
m1.show("hah");
m1.print("heh");
Method_1<Integer> m1_i = new Method_1<Integer>();
m1_i.show(new Integer(110));
m1_i.print(119);
}
public static void method_2(){
Method_2 m2 = new Method_2();
m2.show("哇哈哈");
m2.print(222);
m2.print("嘿嘿");
}
}
class Method_1<D>{//泛型类。
public void show(D d){
System.out.println("（泛型类）Show: " + d);
}
public void print(D d){
System.out.println("（泛型类）Print: " + d);
}
}
class Method_2{
public <Q> void show(Q q){//泛型方法。
System.out.println("（泛型方法）Show: " + q);
}
public <Q> void print(Q q){
System.out.println("（泛型方法）Print: " + q);
}
}

10）静态方法（泛型）

[java] view plain copy

/*
* 静态方法泛型。
* 特殊之处：静态方法不可以访问类上定义的泛型。如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。
注意：泛型放在返回值类型前，修饰符后
static方法需要使用泛型能力，就必须使其成为泛型方法。
*/
public class GenericStaticDemo {
public static void main(String[] args) {
method();
}
public static void method(){
StaticDemo<String> s = new StaticDemo<String>();
s.show("hah");
s.print("heh");
s.print(119);
s.method_Static("哇咔咔");
s.method_Static(new Integer(369));
}
}
class StaticDemo<Q>{
public void show(Q q){
System.out.println("（泛型类）Q： " + q);
}
public <Q> void print(Q q){
System.out.println("（泛型方法）： " + q);
}
public static <Q> void method_Static(Q q){
System.out.println("（静态）（泛型方法）： " + q);
}
}

运行结果如下图所示：

11）接口（泛型）

[java] view plain copy

public class GenericInterDemo {
public static void main(String[] args) {
method();
}
public static void method(){
GenericImpl gi = new GenericImpl();
gi.show("hah");
gi.show("heh");
gi.print(new Integer(119));
gi.print(120);
gi.print("哇哈哈");
}
}
interface GenericInter<I> {//泛型定义在接口上。
void show(I i);
}
class GenericImpl implements GenericInter<String>{
public void show(String s){
System.out.println("（接口）show： " + s);
}
public <I> void print(I i){
System.out.println("（方法）print： " + i);
}
}

运行结果如下图所示：

12）泛型限定（一）

[java] view plain copy

/*
* 泛型的一些高级应用。
* <?>通配符。也可以理解为占位符。
* <? extends E>：可以接受E类型或者E的子类型。<上限限定>。
* <? super E>：可以接受E类型或者E的父类型。<下限限定>。
*/
public class GenericAdvDemo {
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args) {
method_1();
method_2();
method_3();
}
public static void method_1(){
ArrayList<String> al1 = new ArrayList<String>();
al1.add("Java01");
al1.add("Java02");
al1.add("Java03");
printColl_1(al1);
ArrayList<Integer> al2 = new ArrayList<Integer>();
al2.add(01);
al2.add(02);
al2.add(03);
printColl_1(al2);
}
public static void method_2(){
ArrayList<Person_adv> ap1 = new ArrayList<Person_adv>();
ap1.add(new Person_adv("汤姆"));
ap1.add(new Person_adv("汤姆"));
ap1.add(new Person_adv("汤姆"));
printColl_2(ap1);
ArrayList<Student_Adv> ap2 = new ArrayList<Student_Adv>();
ap2.add(new Student_Adv("杰瑞"));
ap2.add(new Student_Adv("杰瑞"));
ap2.add(new Student_Adv("杰瑞"));
printColl_2(ap2);
}
public static void method_3(){
TreeSet<Student_Adv> ts = new TreeSet<Student_Adv>(new Comp());
ts.add(new Student_Adv("斯派克一号"));
ts.add(new Student_Adv("斯派克二号"));
ts.add(new Student_Adv("斯派克二号"));
ts.add(new Student_Adv("斯派克三号"));
ts.add(new Student_Adv("斯派克五号"));
printColl_3(ts);
}
public static void printColl_1(ArrayList<?> al){//<上限限定>
for (Iterator<?> it = al.iterator(); it.hasNext();){
sop(it.next());
}
System.out.println("-----------------------");
}
public static void printColl_2(ArrayList<? extends Person_adv> ap){
for (Iterator<? extends Person_adv> it = ap.iterator(); it.hasNext();){
sop(it.next().getName());
}
System.out.println("-----------------------");
}
public static void printColl_3(TreeSet<? extends Person_adv> ap){
for (Iterator<? extends Person_adv> it = ap.iterator(); it.hasNext();){
sop(it.next().getName());
}
System.out.println("-----------------------");
}
}
class Person_adv{
private String name;
Person_adv(String name){
this.name = name;
}
public String getName(){
return name;
}
}
class Student_Adv extends Person_adv{
Student_Adv(String name){
super(name);
}
}
class Comp implements Comparator<Student_Adv>{//比较器。
public int compare(Student_Adv s1, Student_Adv s2){
return s1.getName().compareTo(s2.getName());
}
}

运行结果如下图所示：

13）泛型限定（二）

[java] view plain copy

/*
* TreeSet通过直接传入父类比较器。
*/
public class GenericAdvDemo_2 {
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args) {
method_1();
method_2();
}
public static void method_1(){
TreeSet<Student_Adv_2> ts = new TreeSet<Student_Adv_2>(new StuComp());//传入父类比较器。
ts.add(new Student_Adv_2("（Stu）Java01"));
ts.add(new Student_Adv_2("（Stu）Java04"));
ts.add(new Student_Adv_2("（Stu）Java02"));
ts.add(new Student_Adv_2("（Stu）Java06"));
ts.add(new Student_Adv_2("（Stu）Java05"));
ts.add(new Student_Adv_2("（Stu）Java02"));
printColl_1(ts);
System.out.println("---Student_Adv_2---");
}
public static void method_2(){
TreeSet<Worker_Adv_2> tw = new TreeSet<Worker_Adv_2>(new AllComp());//传入StuComp（子类）比较器。
tw.add(new Worker_Adv_2("（Wok）Java01"));
tw.add(new Worker_Adv_2("（Wok）Java04"));
tw.add(new Worker_Adv_2("（Wok）Java02"));
tw.add(new Worker_Adv_2("（Wok）Java06"));
tw.add(new Worker_Adv_2("（Wok）Java05"));
tw.add(new Worker_Adv_2("（Wok）Java02"));
printColl_1(tw);
System.out.println("---Person_adv_2---");
}
public static void printColl_1(TreeSet<? extends Person_adv_2> ts){
for (Iterator<? extends Person_adv_2> it = ts.iterator(); it.hasNext();){
sop(it.next().getName());
}
}
}
class AllComp implements Comparator<Person_adv_2>{//AllComp（父类）比较器
public int compare(Person_adv_2 p1, Person_adv_2 p2){
return p2.getName().compareTo(p1.getName());
}
}
class StuComp implements Comparator<Student_Adv_2>{//StuComp（子类）比较器
public int compare(Student_Adv_2 s1, Student_Adv_2 s2){
return s1.getName().compareTo(s2.getName());
}
}
class WorkComp implements Comparator<Worker_Adv_2>{//WorkComp（子类）比较器
public int compare(Worker_Adv_2 w1, Worker_Adv_2 w2){
return w1.getName().compareTo(w2.getName());
}
}
class Person_adv_2{
private String name;
Person_adv_2(String name){
this.name = name;
}
public String getName(){
return name;
}
public String toString(){
return "Person_adv_2： " + name;
}
}
class Student_Adv_2 extends Person_adv_2{
Student_Adv_2(String name){
super(name);
}
}
class Worker_Adv_2 extends Person_adv_2{
Worker_Adv_2(String name){
super(name);
}
}