JAVA中常见的工具类及其方法!!!(Objects类与Object类??)

最新推荐文章于 2024-04-03 21:53:22 发布

不秃头的小黄人

最新推荐文章于 2024-04-03 21:53:22 发布

阅读量791

点赞数 1

分类专栏： java基础文章标签： java java工具类 comparator

本文链接：https://blog.csdn.net/weixin_46273997/article/details/113768344

版权

java基础专栏收录该内容

9 篇文章 0 订阅

订阅专栏

JAVA中常见的工具类及其方法总结

前言
一、Arrays工具类
- - (1)sort方法
  - (2)toString方法
二、Objects类与Object类
三、System类
- - (1) currentTimeMillis方法
  - (2)arraycopy方法
四、Collections类

前言

所谓工具类,就是该类中的方法都是被static修饰的,可以直接通过类名调用,这样的好处是不用去创建对象;在一定程度上简化了我们的使用.以下总结java中几个常见的工具类及其方法!!!

一、Arrays工具类

(1)sort方法

-  public static void sort(数组)按照默认升序,对数组元素进行排序 

	int [] array1 = {2,5,3};
	arrays.sort(array1);//直接在原数组中排好序

注意:

如果是字符串数组,sort默认按照字母升序;
如果是自定义的类型,那么这个自定义的类需要有comparable或者comparator接口的支持

(2)toString方法

-  public static String toString(数组);默认格式:[元素1,元素2,……]

此方法可以把数组转换为字符串

二、Objects类与Object类

Objects类

在JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。

在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题。方法如下：

public static boolean equals(Object a, Object b):判断两个对象是否相等。

我们可以查看一下源码，学习一下：

public static boolean equals(Object a, Object b) {  
    return (a == b) || (a != null && a.equals(b));  
}

Object类

java.lang.Object类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是Object。

(1)equals方法

public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。

调用成员方法equals并指定参数为另一个对象，则可以判断这两个对象是否是相同的。这里的“相同”有默认和自定义两种方式。

默认地址比较

如果没有覆盖重写equals方法，那么Object类中默认进行==运算符的对象地址比较，只要不是同一个对象，结果必然为false。

对象内容比较

如果希望进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同，则可以覆盖重写equals方法。例如：

(2)toString方法

public String toString()：返回该对象的字符串表示。

toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。

由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。

public class Person {  
    private String name;
    private int age;

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

    // 省略构造器与Getter Setter
}

三、System类

(1) currentTimeMillis方法

`public static long currentTimeMillis()`：返回以毫秒为单位的当前时间。

实际上，currentTimeMillis方法就是获取当前系统时间与1970年01月01日00:00点之间的毫秒差值,此方法可以用来计算某个程序所消耗的时间

验证for循环打印数字1-9999所需要使用的时间（毫秒）

public class SystemTest1 {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("共耗时毫秒：" + (end - start));
    }
}

(2)arraycopy方法

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。

参数序号	参数名称	参数类型	参数含义
1	src	Object	源数组
2	srcPos	int	源数组索引起始位置
3	dest	Object	目标数组
4	destPos	int	目标数组索引起始位置
5	length	int	复制元素个数

将src数组中前3个元素，复制到dest数组的前3个位置上复制元素前：src数组元素[1,2,3,4,5]，dest数组元素[6,7,8,9,10]复制元素后：src数组元素[1,2,3,4,5]，dest数组元素[1,2,3,9,10]

import java.util.Arrays;

public class Demo11SystemArrayCopy {
    public static void main(String[] args) {
        int[] src = new int[]{1,2,3,4,5};
        int[] dest = new int[]{6,7,8,9,10};
        System.arraycopy( src, 0, dest, 0, 3);
        /*代码运行后：两个数组中的元素发生了变化
         src数组元素[1,2,3,4,5]
         dest数组元素[1,2,3,9,10]
        */
    }
}

四、Collections类

Collections类是用来对集合进行操作的工具类,包括以下常见方法:

public static <T> boolean addAll(Collection<T> c, T... elements):往集合中添加一些元素。
public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。
public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。
public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则

(1)addAll方法

public class CollectionsDemo {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        //原来写法
        //list.add(12);
        //list.add(14);
        //list.add(15);
        //list.add(1000);
        //采用工具类 完成 往集合中添加元素  
        Collections.addAll(list, 5, 222, 1，2);
        System.out.println(list);
        //排序方法 
        Collections.sort(list);
        System.out.println(list);
    }
}
结果：
[5, 222, 1, 2]
[1, 2, 5, 222]

(2)sort方法

1.public static <T> void sort(List<T> list)这个方法按照默认规则进行排序,即升序

注意:使用这个方法的前提:
是被排序的集合中存储的元素必须实现comparable接口,重写compareTo方法

class Person implements Comparable<Person>{

	private int age;
	private String name;

	.....
	省略get/set方法
	public int compareTo(Person o){
		return this.getAge() - o.getAge();
		//return o.getAge() - this.getAge();
		//return 0;

	}

}
Arraylist<Person> list = new ArrayList<>();
Collections.sort(list);

定义了一个person类,实现了comparable接口,并实现了compareTo()方法
排序规则:

this.xxx - 参数 : 代表升序
参数 - this.xxx : 代表降序
返回0: 代表元素相同

2.public static <T> void sort(List<T> list，Comparator<? super T> )
说明:由于第一种方法是实现comparable接口,这种比较方法需要让排序的类自己实现接口,并且重写方法;
而另一种方法是借助一个比较器(comparator)来进行排序,此时需要重写compare方法

class Person{

	private int age;
	private String name;

	.....
	省略get/set方法
}
Arraylist<Person> list = new ArrayList<>();
Collections.sort(list,new Comparator<Person>(){

	public int compare(Person o1,Person o2){
		return o1-o2;
	} 

//此外我们还可以拓展这个方法
//如果年龄一样就按照名字排序
	/*public int compare(Person o1,Person o2){
	   int result = o1.getAge()-o2.getAge();
		if(result == 0){
			result = o1.getName() - o2.getName();
		}
		return result;
	} 
*/
});

排序规则:
o1 - o2 :代表升序
o2 - o1 :代表降序

comparable和comparator的区别

Comparable接口位于 java.lang包下，Comparator接口位于java.util包下。

Comparable:    内部比较器，
一个类如果想要使用 Collections.sort(list) 方法进行排序，
则需要实现该接口

Comparator:    外部比较器
用于对那些没有实现Comparable接口
或者对已经实现的Comparable中的排序规则不满意进行排序.
无需改变类的结构，更加灵活。（策略模式）