Comparable接口

进行排序的操作：

下列情况下，不能对对象数组进行排序！！public class Person {    private int age;    private String name;//对对象排序按照年龄升序        Person[] per = {
   new Person(23, "张三"),new Person(20, " 李四"),new Person(29, "王五"),new Person(21, "赵六")};        Arrays.sort(per);        for (Person p : per) {            System.out.println(p);        }java.lang.ClassCastException: com.jy.comparor.Person cannot be cast to java.lang.Comparable语法：可以直接使用java.util.Arrays类进行数组的排序操作，但对象所在的类必须实现Comparable接口，用于指定排序接口，Comparable接口定义如下：public interface Comparable
     
      {public int compareTo(T o) ;} 此方法返回一个int类型的数据，但是此int的值只能是以下三种：1：表示大于 -1：表示小于 0：表示相等 对象的排序条件，要满足对象类型可排序：就是该类型实现Comparable接口public class Person implements Comparable
      
        {    private int age;    private String name;@Override    public int compareTo(Person o) {        //Person对象按照年龄排序        if (this.age > o.age) {            return 1;        } else if (this.age < o.age) {            return -1;        } else {            /*//如果年龄相同按照姓名排序            if(this.name.compareTo(o.getName())>0){                return 1;            }else if(this.name.compareTo(o.getName())<0){                return -1;            }else{                return 0;            }*/            return 0;        }    }

另一种比较器：Comparator

如果一个类已经开发完成，但是在此类建立的初期并没有实现Comparable接口， 此时肯定是无法进行对象排序操作的，所以为了解决这样的问题， java又定义了另一个比较器的操作接口 —— Comparator。 此接口定义在java.util包中，接口定义如下： 可以单写一个类，或者用匿名类的方式进行调用public interface Comparator
     
      {        public int compare(T o1,T o2) ;        boolean equals(Object obj) ;    }

package com.zym.com.zym;import java.util.Comparator;public class Mycomparor implements Comparator
     
       {    @Override    public int compare(Stu o1, Stu o2) {        if (o1.getAge()>o2.getAge()) {            return 1;        } else if (o1.getAge()

package com.zym.com.zym;public class Stu {    private int age;    private String name;    public Stu() {        super();    }    public Stu(int age, String name) {        super();        this.age = age;        this.name = name;    }    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 String toString() {        return "Student [age="+age+",name="+name+"]";    }}

Stu

package com.zym;import com.zym.com.zym.Mycomparor;import com.zym.com.zym.Stu;import java.text.DecimalFormat;import java.util.Arrays;import java.util.Calendar;public class str {    public static void main(String[] args) {        Stu []  arr ={
    new Stu(18,"zym"),new Stu(19,"zzz"),new Stu(20,"yyy")};        Arrays.sort(arr,new Mycomparor());        for (Stu s:arr) {            System.out.println(s);        }    }}

test

对象操作

对象比较是否相等：对象属性类型的类要重写equals方法；

对对象数组排序：对象类型要实现Comparable接口；

正则表达式

正则表达式可以方便的对数据进行匹配，可以执行更加复杂的字符串验证、拆分、替换功能。

例如：现在要求判断一个字符串是否由数字组成，则可以有以下的两种做法：

不使用正则完成

使用正则完成

Pattern、Matcher类

如果要想在程序中应用正则表达式则必须依靠Pattern类与Matcher类，这两个类都在java.util.regex包中定义。Pattern类的主要作用是进行正则规范（如之前的“[0-9]”就属于正则规范）的编写，而Matcher类主要是执行规范，验证一个字符串是否符合其规范。

*/              String str="2bc";//           String str1="bc";//           String reg="a?bc";//           String reg="a+bc";//           String reg="a{2}bc"; //==2//           String reg="a{2,}bc";// >=2//           String reg="a{2,4}bc"; //>=2 <=4//           String reg="[abc]bc"; //a,b,c//           String reg="[^abc]bc"; //非a,b,c//           String reg="[a-zA-Z]bc"; //只能是字母              String reg="[a-zA-Z]bc"; //非a,b,c              System.out.println(Pattern.compile(reg).matcher(str).matches()); // 预定义字符类              String str="@";//           String reg ="\\d";//数字//           String reg ="\\D";//非数字//           String reg ="\\s";//空白//           String reg ="\\S";//非空白//           String reg ="\\w";//单词              String reg ="\\W";//非单词              System.out.println(Pattern.compile(reg).matcher(str).matches()); public static void main(String[] args) {              String email="abcdefgh@sohu.com.cn";               /**\w{3,8}:字母或数字只能出现>=3 <=8                * (com|cn|gov):com,cn,gov 中的任何一个                * (\\.(com|cn|gov))+  ：.com ,.cn,.gov 可以出现1-n次                */              String reg="\\w{3,8}@\\w+(\\.(com|cn|gov))+";                           System.out.println(Pattern.compile(reg).matcher(email).matches());       }

线程操作：

创建线程的方式一：

继承Threadpublic class str {    public static void main(String[] args) {        class MyThread1 extends Thread{            @Override            public void run() {                System.out.println("Thread1");            }        }        new MyThread1().run();        new MyThread1().start();//启动线程，虚拟机自动调用run方法。    }}

创建线程的方式二：（推荐）

在Java中也可以通过实现Runnable接口的方式实现多线程，Runnable接口中只定义了一个抽象方法： public void run() ;通过Runnable接口实现多线程：class 类名称 implements Runnable{    // 实现Runnable接口        属性… ;             // 类中定义属性            方法… ;             // 类中定义方法            public void run(){                // 覆写Runnable接口里的run()方法        线程主体 ;         }    }public class MyThead2 implements Runnable {    @Override    public void run() {        for (int i = 0; i < 10; i++) {            System.out.print(i+"  ");        }    }}public static void main(String[] args) {        Runnable r=new MyThead2();//实例化线程        //启动线程        Thread t=new Thread(r); //通过Thread的有参构造方法实例化线程，启动线程        t.start();            }

创建线程的方式三：

在Java中也可以通过实现Callable接口的方式实现多线程，Callable 接口中只定义了一个抽象方法：  public Integer call() throws Exception ;通过Callable接口实现多线程：class 类名称 implements Callable{    // 实现Callable接口        属性… ;             // 类中定义属性            方法… ;             // 类中定义方法             public Integer call() throws Exception { // 覆写Callable接口里的call()方法        线程主体 ;         }    }public class MyThread3 implements Callable
     
        {    @Override    public Integer call() throws Exception {        for (int i = 0; i < 10; i++) {            System.out.print(i+"  ");        }        int a=10;        int b=10;        return a+b;    }    }public class TestThread3 {    public static void main(String[] args) throws InterruptedException, ExecutionException {            Callable
      
        m = new MyThread3();            FutureTask
       
         f = new FutureTask<>(m);// FutureTask实现了Runnable接口         //启动线程            Thread t= new Thread(f);            t.start();            Integer in = f.get();//获得call的返回值            System.out.println(in);            }}

Thread类和Runnable、Callable接口的区别

实际上Thread类和Runnable/Callable接口之间在使用上也是有所区别的，如果一个类继承Thread类，则不适合于多个线程共享资源，而实现了Runnable/Callable接口，则可以方便的实现资源的共享。但Callable接口里定义的方法有返回值，可以声明抛出异常而已。

线程名字的设置：

默认获得的线程名称方式为:Thead-0 1 2 3 4 Thread：public class Thread1 extends Thread{    @Override    public void run() {        for (int i = 1; i <=20; i++) {            System.out.println(this.getName()+":"+i);//获得线程名称        }    }}public class TestThread1 {    public static void main(String[] args) {
   //主线程        System.out.println(Thread.currentThread().getName());                // 实例化线程        Thread1 t1 = new Thread1();        // 自己设置名称//        t1.setName("我的线程1");        t1.start();        Thread1 t2 = new Thread1();        // 自己设置名称        t2.setName("我的线程2");        t2.start();        Thread1 t3 = new Thread1();        // 自己设置名称        t3.setName("我的线程3");        t3.start();    }}Runnable：public class Thread2 implements Runnable{    @Override    public void run() {        for (int i =1; i <=10; i++) {            System.out.println(Thread.currentThread().getName()+":"+i);        }            }}public class TestThread2 {    public static void main(String[] args) {        Runnable r=new Thread2();        Thread t = new Thread(r, "线程1");        t.start();        Thread t1 = new Thread(r, "线程2");        t1.start();    }}

sleep(long millis) (毫秒)

转载于:https://www.cnblogs.com/taozizainali/p/10851046.html

你可能感兴趣的文章