对象排序

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<T>{
public int compareTo(T o) ;
} 
此方法返回一个int类型的数据，但是此int的值只能是以下三种：
1：表示大于 
-1：表示小于 
0：表示相等 

对象的排序条件，要满足对象类型可排序：就是该类型实现Comparable接口
public class Person implements Comparable<Person> {
    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<T>{
        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<Stu> {


    @Override
    public int compare(Stu o1, Stu o2) {
        if (o1.getAge()>o2.getAge()) {

            return 1;
        } else if (o1.getAge()<o2.getAge()) {
            return -1;
        }else {
            return 0;
        }


   

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+"]";
    }
}

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);
        }
    }

}

对象操作

对象比较是否相等：对象属性类型的类要重写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());

       }

线程操作：

创建线程的方式一：

继承Thread
public 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<Integer>  {

    @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<Integer> m = new MyThread3();
            FutureTask<Integer> 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)   (毫秒)