Java常用类

最新推荐文章于 2024-10-17 15:34:15 发布

wyyyyyk

最新推荐文章于 2024-10-17 15:34:15 发布

阅读量133

点赞数 5

分类专栏： Java笔记文章标签：大数据

本文链接：https://blog.csdn.net/wyk112233/article/details/125575522

版权

Java笔记专栏收录该内容

7 篇文章 1 订阅

订阅专栏

一、字符串相关的类：String

字符串的特性

public class StringTest {

    /*
    结论：
    1.常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
    2.只要其中有一个是变量，结果就在堆中
    3.如果拼接的结果调用intern()方法，返回值就在常量池中


     */
    @Test
    public void test3(){
        String s1 = "javaEE";
        String s2 = "hadoop";

        String s3 = "javaEEhadoop";
        String s4 = "javaEE" + "hadoop";
        String s5 = s1 + "hadoop";
        String s6 = "javaEE" + s2;
        String s7 = s1 + s2;

        System.out.println(s3 == s4);//true
        System.out.println(s3 == s5);//false
        System.out.println(s3 == s6);//false
        System.out.println(s3 == s7);//false
        System.out.println(s5 == s6);//false
        System.out.println(s5 == s7);//false
        System.out.println(s6 == s7);//false

        String s8 = s5.intern();//返回值得到的s8使用的是常量池中已经存在的“javaEEhadoop”
        System.out.println(s3 == s8);//true

    }




    /*
    String的实例化方式：
    方式一：通过字母量定义的方式
    方式二：通过new + 构造器的方式

    面试题：String s = new String("abc");方式创建对象，在内存在创建了几个对象
               两个：一个是堆空间new结构，另一个是char[]对应的常量池中的数据：“abc”



     */

    @Test
    public void test2(){
        //通过字面量定义的方式：此时的s1和s2的数据声明在方法区爱情的常量值中
        String s1 = "javaEE";
        String s2 = "javaEE";

        //通过new + 构造器的方式：此时s3和s4保存的地址值，是数据在堆空间中开辟空间以后对应的地址值
        String s3 = new String("JavaEE");
        String s4 = new String("JavaEE");

        System.out.println(s1 == s2);//true
        System.out.println(s1 == s3);//false
        System.out.println(s1 == s4);//false
        System.out.println(s3 == s4);//false

        System.out.println("****************************************");
        Person p1 = new Person("Tom",12);
        Person p2 = new Person("Tom",12);

        System.out.println(p1.name.equals(p2.name));//true
        System.out.println(p1.name == p2.name);//true

        p1.name = "jerry";
        System.out.println(p2.name);

    }



    /*
    String：字符串。使用一对“”引起来表示。
    1.String声明为final的，不可能被继承
    2.String实现了Serializable接口：表示字符串是支持序列化的。
            实现了Comparable接口：表示String可以比较大小
    3.String内部定义了final  char[]  value用于存储字符串数据
    4.String：代表不可变的字符序列。简称：不可变性
           体现：1.当对字符串重写赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值
                2.当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能在原有的value上赋值。
                3.当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值
    5.通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中。
    6.字符串常量池是不会存储相同内容的字符串的。




     */
    @Test
    public void test1(){
        String s1 = "abc";//字面量
        String s2 = "abc";
        //s1 = "hello";

        System.out.println(s1 == s2);

        System.out.println(s1);//hello
        System.out.println(s2);//abc

        System.out.println("*****************************************");

        String s3 ="abc";
        s3 += "def";
        System.out.println(s3);
        System.out.println(s2);

        System.out.println("*****************************************");

        String s4 = "abc";
        String s5 = s4.replace('a','m');
        System.out.println(s4);
        System.out.println(s5);


    }

}

String的常用方法：

字符串相关的类：StringBuffer

字符串相关的类：StringBuilder

二、JDK8之前日期时间API

三、JDK8中新日期时间API

第三次引入的API是成功的，并且Java 8中引入的java.time API 已经纠正了过去的缺陷，将来很长一段时间内它都会为我们服务。Java 8 吸收了 Joda-Time 的精华，以一个新的开始为 Java 创建优秀的 API。新的 java.time 中包含了所有关于本地日期（LocalDate）、本地时间（LocalTime）、本地日期时间（LocalDateTime）、时区（ZonedDateTime）和持续时间（Duration）的类。历史悠久的 Date 类新增了 toInstant() 方法，用于把 Date 转换成新的表示形式。这些新增的本地化时间日期 API大大简化了日期时间和本地化的管理

LocalDate、LocalTime、LocalDateTime 类是其中较重要的几个类，它们的实例是不可变的对象，分别表示使用 ISO-8601日历系统的日期、时间、日期和时间。它们提供了简单的本地日期或时间，并不包含当前的时间信息，也不包含与时区相关的信息。 LocalDate代表IOS格式（yyyy-MM-dd）的日期,可以存储生日、纪念日等日期。 LocalTime表示一个时间，而不是日期。 LocalDateTime是用来表示日期和时间的，这是一个最常用的类之一。。

四、Java比较器

在Java中经常会涉及到对象数组的排序问题，那么就涉及到对象之间的比较问题。 Java实现对象排序的方式有两种：

自然排序：java.lang.Comparable

定制排序：java.util.Comparator

一、实现Comparable接口：自然排序

/*
    Comparable接口的使用举例：   自然排序
 *      1.像String、包装类等实现了Comparable接口，重写了compareTo方法，给出了比较两个对象大小的方式
 *      2.像String、包装类重写CompareTo方法以后，进行从小到大的排序
 *      3.重写CompareTo（obj）的规则：
 *      如果当前对象this大于形参对象obj，则返回正整数，
 *      如果当前对象this小于形参对象obj，则返回负整数，
 *      如果当前对象this等于形参对象obj，则返回零。
 *      4.对于自定义类如果需要排序，我们可以让人自定义类实现Comparable接口，重写compareTo()方法
 *      在compareTo（obj）方法中指明如何排序

*/

    @Test
    public void test1(){
        String[] arr = new String[]{"AA","CC","MM","DD"};
        Arrays.sort(arr);

        System.out.println(Arrays.toString(arr));

    }

    @Test
    public void test2(){
        Goods[] arr = new Goods[5];
        arr[0] = new Goods("lenovoMouse",34);
        arr[1] = new Goods("dellMouse",43);
        arr[2] = new Goods("xiaomiMouse",12);
        arr[3] = new Goods("huaweiMouse",65);
        arr[4] = new Goods("microsoftMouse",65);

        Arrays.sort(arr);

        System.out.println(Arrays.toString(arr));

    }











public class Goods implements Comparable{

    private String name;
    private double price;

    public Goods() {
    }

    public Goods(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Goods{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }

    //指明商品比较大小方式:按照价格从海底到高排序,再按产品名称从高到低排序
    @Override
    public int compareTo(Object o) {
        if(o instanceof Goods) {
            Goods goods = (Goods) o;
            if (this.price > goods.price) {
                return 1;
            } else if (this.price < goods.price) {
                return -1;
            } else {
                //return 0;
                return -this.name.compareTo(goods.name);
            }
        }
        throw new RuntimeException("传入的数据类型不一致");
    }
}

二、使用Comparator：定制排序

 /*
    Comparator接口的使用：  定制排序
    1.背景：
    当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，
    或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，那
    么可以考虑使用 Comparator 的对象来排序
    2.重写compare(Object o1,Object o2)方法，比较o1和o2的大小：如果方法返
    回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示
    o1小于o2。
     */


    @Test
    public void test3(){
        String[] arr = new String[]{"AA","CC","MM","DD"};

        Arrays.sort(arr,new Comparator(){

            //按照字符串从大到小的顺序排列
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof String && o2 instanceof String){
                    String s1 = (String)o1;
                    String s2 = (String)o2;
                    return -s1.compareTo(s2);
                }
                throw new RuntimeException("输入的数据不一致");
            }
        });

        System.out.println(Arrays.toString(arr));

    }

    @Test
    public void test4(){
        Goods[] arr = new Goods[6];
        arr[0] = new Goods("lenovoMouse",34);
        arr[1] = new Goods("dellMouse",43);
        arr[2] = new Goods("xiaomiMouse",12);
        arr[3] = new Goods("huaweiMouse",65);
        arr[4] = new Goods("microsoftMouse",224);
        arr[5] = new Goods("microsoftMouse",65);

        Arrays.sort(arr, new Comparator() {
            //指明商品比较大小方式:按照产品名称从底到高排序,再按价格从高到低排序
            @Override
            public int compare(Object o1, Object o2) {
               if(o1 instanceof Goods && o2 instanceof Goods){
                   Goods g1 = (Goods)o1;
                   Goods g2 = (Goods)o2;
                   if(g1.getName().equals(g2.getName())){
                        return -Double.compare(g1.getPrice(),g2.getPrice());
                   }else{
                       return g1.getName().compareTo(g2.getName());
                   }
               }
                throw new RuntimeException("输入的数据不一致");
            }
        });

        System.out.println(Arrays.toString(arr));


    }