java基础_Day15

现在的位置: 首页 > 综合 > 正文

RSS

2017年09月30日 ⁄ 综合 ⁄ 共 11384字 ⁄ 字号小中大 ⁄ 评论关闭

1，TreeSet：

底层数据结构是二叉树，保证元素唯一性的依据：compare方法return 0。

可以对集合中的元素进行排序，本身是按照自然顺序排序

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

TreeSet中存储自定义对象，并且对其进行排序：

eg:

import java.util.*;

class Student implements Comparable//该接口强制让学生具备比较性，Comparable中只有一个compareTo方法

{

     private String name;

     private int age;

     Student(String name,int age)

     {

          this.name=name;

          this.age=age;

     }

     public String getName()

     {

          return name;

     }

     public int getAge()

     {

          return age;

     }

     public int compareTo(Object obj)//这里不能声明，因为方法是覆盖了的方法？

     {

          if(!(obj instanceof Student))

               throw new RuntimeException("不是学生对象");

          Student s = (Student)obj;

          System.out.println(this.name+"-------"+s.name);

          if(this.age>s.age)

               return 1;

          if(this.age==s.age)//当主要条件相同时，应该判断一下次要条件

               return this.name.compareTo(s.name);//String类有compareTo的方法

          return -1;

     }

}

class TreeSetDemo

{

     public static void main(String[] args)

     {

          TreeSet tr = new TreeSet();

          tr.add(new Student("zhangsan",34));

          tr.add(new Student("lishi",67));

          tr.add(new Student("wangwu",12));

          tr.add(new Student("lishi",67));

//          Exception in thread "main" java.lang.ClassCastException: Student cannot be cast

//          to java.lang.Comparable

//                    at java.util.TreeMap.put(TreeMap.java:542)

//                    at java.util.TreeSet.add(TreeSet.java:238)

//                    at TreeSetDemo.main(TreeSetDemo.java:27)

//          请按任意键继续. . .

//解释：TreeSet默认排序，但是Student根本就不具备比较性，所以必须让其元素具备比较性。



          Iterator it = tr.iterator();

          while(it.hasNext())

          {

               Student s = (Student)it.next();

               System.out.println(s.getName()+"...."+s.getAge());

          }

     }

}

2，二叉树：

1，二叉树结构：

存数据：当数据多的时候会折中比较

取数据：从小大大取

2，存取顺序一致：将红色代码修改为：return 1;

存取顺序相反：将红色代码修改为：return 1;

只存取第一个元素：将红色代码修改为：return 0；

3，Tree排序的第二中排序方式：

当元素自身不具有比较性时，或者具备的比较性不是所需要的，这时就需要让集合自身具备比较性

eg1:

//按姓名排序。

import java.util.*;

class person implements Comparable

{

     private String name ;

     private int age;

     person(String name,int age)

     {

          this.name=name;

          this.age=age;

     }

     public String getName()

     {

          return name;

     }

     public int getAge()

     {

          return age;

     }

     public int compareTo(Object obj)

     {

          if(!(obj instanceof person))

               throw new RuntimeException();

          person p = (person)obj;

          if(this.age>p.age)

               return 1;

          if(this.age==p.age)

               return 0;

          return -1;

     }

}

class Mycompare implements Comparator

{

     public int compare(Object o1,Object o2)

     {

          person p1 = (person)o1;

          person p2 = (person)o2;

          int num = p1.getName().compareTo(p2.getName());

          if(num==0)

          {

//               if(p1.getAge()>p2.getAge())
//                    return 1;
//               if(p1.getAge()<p2.getAge())
//                    return -1;
//               return 0;
return new Integer(p1.getAge()).compareTo(new Integer(p2.getAge()));

          }

          return num;

     }

}

class TreeSetCompare

{

     public static void main(String[] args)

     {

          TreeSet tr = new TreeSet(new Mycompare());

          tr.add(new person("zhangsan",89));

          tr.add(new person("wangwu",24));

          tr.add(new person("lishi",56));

          tr.add(new person("dadada",9));

          Iterator it = tr.iterator();

          while(it.hasNext())

          {

               Object obj = it.next();

              person p = (person)obj;

               System.out.println(p.getName()+":::"+p.getAge());

          }

     }

}

eg2:

//按照字符串长度排序：

import java.util.*;
class TreeSetTest
{
     public static void main(String[] args)
     {
          TreeSet tr = new TreeSet(new Mycompare());
          tr.add("aaa");
          tr.add("c");
          tr.add("bbb");
          tr.add("dadada");
          tr.add("Dcb");
          Iterator it = tr.iterator();
          while(it.hasNext())
          {
               System.out.println(it.next());
          }
     }
}
class Mycompare implements Comparator
{
     public int compare(Object o1,Object o2)
     {
          String s1 = (String)o1;
          String s2 = (String)o2;
//          if(s1.length()>s2.length())
//               return 1;
//          if(s1.length()==s2.length())
//          {
//               return s1.compareTo(s2);
//          }
//          return -1;
          int num = new Integer(s1.length()).compareTo(s2.length());
          if(num>0)
               return 1;
          if(num==0)
               return s1.compareTo(s2);
          return num;
     }
}

4，泛型：JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。

集合中只能添加对象，不能添加基本数据类型，但是JDK1.5之后可以直接添加。自动装箱原理；

好处：

1.将运行时期出现问题ClassCastException，转移到了编译时期。
方便于程序员解决问题。让运行时问题减少，安全。
2，避免了强制转换麻烦。

eg1:

import java.util.*;

class GenericDemo

{

     public static void main(String[] args)

     {

          ArrayList<String> al = new ArrayList<String>();

          al.add("java01");

          al.add("java02");

          al.add("java03");

// al.add(4);

          Iterator<String> it = al.iterator();

          while(it.hasNext())

          {

               String s = it.next();

               System.out.println(s+"   "+s.length());

          }

     }

}

eg2：

按照字符串长度比较，使用泛型：

import java.util.*;

class GenericUser

{

     public static void main(String[] args)

     {

          TreeSet<String> tr = new TreeSet<String>(new Mycompare());

          tr.add("abcd");

          tr.add("aaa");

          tr.add("vb");

          tr.add("sb");

          Iterator<String> it = tr.iterator();

          while(it.hasNext())

          {

               sop(it.next());

          }

     }

     public static void sop(Object obj)

     {

          System.out.println(obj);

     }

}

class Mycompare implements Comparator<String>//这里定义了泛型后compare就可以直接传入自定义的类型了，类型定义在接口上，子类实现时必须使用该类型

{

     public int compare(String s1,String s2)

     {

          int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));

//          if (num>0)

//               return 1;

          if(num==0)

               return s1.compareTo(s2);

//          return -1;

          return num;

     }

}

5，泛型类？
当类中要操作不确定的引用数据类型时，定义泛型。好处：1，让问题出现在编译时期；2，省去强制类型转换的麻烦。
早期是定义Object来往完成功能扩展的:

class Student
{
}
class Worker
{
}
//class Tool//早期的做法
//{
//     private Object obj;
//     public void setObject(Object obj)
//     {
//          this.obj=obj;
//     }
//     public Object getObject()
//     {
//          return obj;
//     }
//}
class Utils<T>
{
     private T t;
     public void setObject(T t)
     {
          this.t=t;
     }
     public T getObject()
     {
          return t;
     }
}
class GenericDemo1
{
     public static void main(String[] args)
     {
//          Tool t = new Tool();
//          t.setObject(new Worker());
//          Worker w = (Worker)t.getObject();
          Utils<Worker> t = new Utils<Worker>();
          t.setObject(new Worker());
          t.getObject();
     }
}

6，泛型方法:

让不同的方法可以操作不同的数据类型，这时候可以将泛型定义在方法上。

eg1:

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 GenericDemo2

{

     public static void main(String[] args)

     {

          Demo d = new Demo();

          d.show("java");

          d.print(3);

     }

}

    eg2:泛型类的泛型方法：

7，静态方法泛型：

静态方法泛型不可以访问类上的泛型。

如果静态方法操作的数据类型不确定时，可以将泛型定义在方法上。

eg:

class Demo<T>

{

     public <T> void show(T t)

     {

          System.out.println("show："+t);

     }

     public static <T> void print(T t)

     {

          System.out.println("print："+t);

     }

}

class GenericDemo2

{

     public static void main(String[] args)

     {

          Demo <String> d = new Demo<String>();

          d.show("java");

          Demo.print(3);

     }

}

8，泛型接口：

1，子类实现确定了数据类型；

2，子类实现没有确定数据类型，子类仍然为泛型类，具体数据类型由调用者确定

interface Inner<T>

{

     void show(T t);

}

//class InnerDemo implements Inner<String>

//{

//     public void show(String t)

//     {

//          System.out.println("show："+t);

//     }

//}

class InnerDemo<T> implements Inner<T>

{

     public void show(T t)

     {

          System.out.println("show："+t);

     }

}

class GenericDemo3

{

     public static void main(String[] args)

     {

//          InnerDemo d = new InnerDemo();

//          d.show("java");

          InnerDemo<Integer> d1 = new InnerDemo<Integer>();

          d1.show(6);

     }

}

9，泛型限定

<?>通配符，也可以理解为占位符。

泛型限定：

？extends E :可以接受E类型或者E类型的子类型，上限

？super E :可以接受E类型或者E类型的父类型，下限

好处：提高了扩展性
弊端：但是不能使用类型的特有方法

eg1:

import java.util.*;

class person

{

     private String name;

     private int age;

     person(String name,int age)

     {

          this.name=name;

          this.age=age;

     }

     public String getName()

     {

          return name;

     }

     public int getAge()

     {

          return age;

     }

}

class Student extends person

{

     Student(String name,int age)

     {super(name,age);}

}

class GenericDemo11

{

     public static void main(String[] args)

     {

          ArrayList<Integer> al = new ArrayList<Integer>();

          al.add(4);

          al.add(6);

          al.add(45);

          al.add(2);

//          printColl(al);

          ArrayList<String> al1 = new ArrayList<String>();

          al1.add("aaa");

          al1.add("abc");

          al1.add("vbd");

          al1.add("nvb");

//          printColl(al1);

          ArrayList<person> p = new ArrayList<person>();

          p.add(new person("person1 ：",1));

          p.add(new person("person2 ：",2));

          p.add(new person("person3 ：",3));

          p.add(new person("person4 ：",4));

          printColl2(p);

          System.out.println();

          ArrayList<Student> s = new ArrayList<Student>();

          s.add(new Student("Student1: ",11));

          s.add(new Student("Student2: ",22));

          s.add(new Student("Student3: ",33));

          s.add(new Student("Student4: ",44));

          printColl2(s);

     }

     public static void printColl2(ArrayList<? extends person> p)

     {

          Iterator<? extends person> it = p.iterator();

          while(it.hasNext())

          {

               person p1 = it.next();

               System.out.println(p1.getName()+p1.getAge());

          }

     }

//     public static void printColl(ArrayList<String> al)

     public static void printColl(ArrayList<?> al)

//     public static <T> void printColl(ArrayList<T> al)

     {

//          Iterator<String> it = al.iterator();

          Iterator<?> it = al.iterator();

//          Iterator<T> it = al.iterator();

          while(it.hasNext())

          {

//               T t = it.next();//用<T>时可以接收并操作这个类型

               System.out.println(it.next());//泛型不能使用类型特有方法，比如可以使用toString(),不能使用length().

          }

     }

}

eg2:

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 comp implements Comparator<person>

{

     public int compare(person p1,person p2)

     {

          return p2.getName().compareTo(p1.getName());/这里的方法必须是父类型的方法

     }

}

class GenericDemo22

{

     public static void main(String[] args)

     {

          TreeSet<person> tr = new TreeSet<person>(new comp());

          tr.add(new person("java01"));

          tr.add(new person("java02"));

          tr.add(new person("java03"));

          tr.add(new person("java04"));

          Iterator<person> it = tr.iterator();

          while(it.hasNext())

          {

               System.out.println(it.next().getName());

          }

          System.out.println();

          TreeSet<Worker> wr = new TreeSet<Worker>(new comp());

          wr.add(new Worker("hoodlop01"));

          wr.add(new Worker("hoodlop02"));

          wr.add(new Worker("hoodlop03"));

          wr.add(new Worker("hoodlop04"));

          Iterator<Worker> it1 = wr.iterator();

          while(it1.hasNext())

          {

               System.out.println(it1.next().getName());

          }

     }

}

【上篇】java基础_Day14
【下篇】java基础_Day09

作者: nomadic

该日志由 nomadic 于7年前发表在综合分类下，最后更新于 2017年09月30日.
转载请注明: java基础_Day15 | 学步园 +复制链接

抱歉!评论已关闭.

学步园

java基础_Day15

作者: nomadic

书签

最新文章New

本站推荐

返回首页