码迷,mamicode.com
首页 > 编程语言 > 详细

对象排序

时间:2019-05-12 10:52:07      阅读:162      评论:0      收藏:0      [点我收藏+]

标签:pareto   ati   nbsp   .text   col   mail   sleep   hid   src   

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

       }

线程操作:

创建线程的方式一:

继承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)   (毫秒)

 

对象排序

标签:pareto   ati   nbsp   .text   col   mail   sleep   hid   src   

原文地址:https://www.cnblogs.com/taozizainali/p/10851046.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!