JavaSE常用类及方法的介绍（附代码）

1、基本数据类型比较用：==

2、引用数据类型比较用：equals方法

如果引用数据类型使用==比较的话，比较的是地址值

toString类

对象调用toString()需要重写本方法: 在封装类中,否则输出的是地址

equals方法

'对象' 调用equals()需要重写本方法: 在封装类中重写,否则进行比较时比较的是地址

String类

String有一个切割split，按一个字符串进行切割，返回切割之后的字符串数组

String[] split(String regex)

public int length () ：返回此字符串的长度。

public String concat (String str) ：将指定的字符串连接到该字符串的末尾。

public char charAt (int index) ：返回指定索引处的 char值。

public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。

public int indexOf(String str, int fromIndex) ：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。

public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。

public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。

public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使用replacement字符串替换。

StringBuilder类

String Builder在内存中相当于一个缓冲容器,会随着内存的关闭而消失,在地址内存中进行字符拼接时 不创建所添加字符的内存地址 节省了内存空间

StringBuilder() 构造一个没有字符的字符串构建器，初始容量为16个字符。

StringBuilder(String str) 构造一个初始化为指定字符串内容的字符串构建器

StringBuilder sb = new StringBuilder();

public StringBuilder append(任意类型)：添加数据，并返回对象本身(支持链式调用)。

public StringBuilder reverse()：字符序列进行反转

public String toString()：返回此序列中数据的字符串表示形式。 转为String

append方法弊端：它可以拼接任意类型，但是拼接完毕，都变成字符串

Arrays类

public static String toString(int[] a)：把数组转成字符串

public static void sort(int[] a)：对数组进行升序排序

包装类与String类互相转换

int 类型直接拼接字符串可转为String类型

int->String

1+""

String.valueOf()方法可以将基本类型数据转为String类型

String.valueOf(数据);

包装类.ParseXXX方法可以将基本类型转为String类型 注意基本类型必须转为相对应的包装类,以下是int转String例子

int->String(重点)

Integer.parseInt("100")

Date类

在java，有一个java.util.Date,表示日期时间的，精确到毫秒值

Date类的构造方法：

Date() 无参构造方法：以当前的系统时间来创建出一个Date对象

Date(long date)：根据指定的毫秒值，创建出一个Date对象。 指定的毫秒值，从1970年1月1日(计算机的基准时间)起经过的毫秒值

常用方法：

public long getTime() 把日期对象转换成对应的时间毫秒值。

void setTime(long time) 将此 Date对象设置为1970年1月1日00:00:00 起经过的毫秒值

//请打印出1970年1月2号的时间的对象
　　　　Date date2 = new Date(24 * 60 * 60 * 1000);
　　　　System.out.println(date2);
　　//获取当前时间的毫秒值
　　　　Date date = new Date();
　　　　System.out.println(date.getTime());
　　//将date，改成1970年1,月1号 　　
　　　　date.setTime(0);
　　　　System.out.println(date);

SimpleDateFormat类

可以使用DateFormat类，但是它是一个抽象类，所以我们要用它的子类 SimpleDateFormat构造方法

SimpleDateFormat(String pattern) 使用给定模式构建一个 SimpleDateFormat ，默认日期格式符号为默认的 FORMAT区域设置。

参数pattern就是模式

字母模式：y表示面 M表示月 d表示日 H表示时 m表示分 s表示秒 S表示毫秒

中国式时间： 2019年3月11日 11点 09分 33秒 333毫秒

代码的字母模式： yyyy年MM月dd日 HH点mm分ss秒 SSS毫秒

成员方法 :

格式化（日期 -> 文本）: Date -- String

public final String format(Date date)

解析（文本 -> 日期）: String -- Date

public Date parse(String source)

//根据系统时间创建Date对象
        Date date = new Date();
        System.out.println(date);

        //date不好看，格式化为中国式时间
　　　　 //SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日  HH点mm分ss秒 SSS毫秒");
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM-dd  HH:mm:ss");
        //将date格式化为String
        String time = sdf.format(date);
        System.out.println(time);

        //注意，我们一般人不会记忆毫秒值，能不能根据具体的时间(2019-03-11  11:16:02)解析成毫秒值
        //ParseException: Unparseable date: "2018年03-11  11:18:57",注意，模式必须与之前一致
        Date date1 = sdf.parse("2018年03-11  11:18:57");
        System.out.println(date1);
        System.out.println(date1.getTime());

Calendar类

Calendar为抽象类，由于语言敏感性，Calendar类在创建对象时并非直接创建，而是通过静态方法创建，返回子类对象

根据Calendar类的API文档，常用方法有：

public int get(int field)：返回给定日历字段的值。

public void set(int field, int value)：将给定的日历字段设置为给定值。

public abstract void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量。

public Date getTime()：返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象。

Calendar类中提供很多成员常量，代表给定的日历字段：

import java.util.Calendar;
public class CalendarUtil {
    public static void main(String[] args) {
        //get方法
        // 创建Calendar对象
        Calendar cal = Calendar.getInstance();
        // 设置年 
        int year = cal.get(Calendar.YEAR);
        // 设置月
        int month = cal.get(Calendar.MONTH) + 1;
        // 设置日
        int dayOfMonth = cal.get(Calendar.DAY_OF_MONTH);
        //set方法
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.YEAR, 2020);
        //add方法
        cal.add(Calendar.DAY_OF_MONTH, 2); // 加2天
        cal.add(Calendar.YEAR, -3); // 减3年
        //getTime方法
        Date date = cal.getTime();
    }    
}

System类

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

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

currentTimeMillis方法

import java.util.Date;

public class SystemDemo {
    public static void main(String[] args) {
           //获取当前时间毫秒值
        System.out.println(System.currentTimeMillis()); // 1516090531144
    }
}

arraycopy方法

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]
        */
    }
}

Random类

构造方法：

Random() 创建一个新的随机数生成器。

成员方法 :

int nextInt() 从这个随机数生成器的序列返回下一个伪随机数，均匀分布的 int值。

int nextInt(int bound) ，均匀分布 返回值介于0（含）和指定值bound（不包括），从该随机数生成器的序列绘制

Random random = new Random();
        /*for (int i = 0; i < 10; i++) {
            System.out.println(random.nextInt());
        }*/
        /*for (int i = 0; i < 10; i++) {
            int j = random.nextInt(10);
            System.out.println(j);
        }*/
        //来一个随机值，这个数据的范围必须是1~100,33~66 54~78
        //random.nextInt(100);//0~99 +1 -> 1~100
        /*33~66 - 33 -> 0~33
        for (int i = 0; i < 10; i++) {
            System.out.println(random.nextInt(34) + 33);
        }*/
        //54~78 - 54 -> 0~24
        for (int i = 0; i < 10; i++) {
            System.out.println(random.nextInt(25) + 54);
        }

比较器Comparable<T> 和 Comparator<T>

java.lang Comparable<T> : 该接口对实现它的每个类的对象强加一个整体排序。 这个排序被称为类的自然排序 ，类的compareTo方法被称为其自然比较方法 。

java中规定 某个类只要实现了Comparable 接口之后,才能通过重写compareTo()具备比较的功能。

抽象方法:

int compareTo(T o) 将此对象(this)与 指定( o )的对象进行比较以进行排序。

this > o : 返回正数

this = o : 返回0

this < o : 返回负数

' this - o : 表示按照升序排序。 o - this : 表示按照降序排序。

' 小结 : 如果Java中的对象需要比较大小，那么对象所属的类要实现Comparable接口，然后重写compareTo(T o)实现比较的方式。

public class Student implements Comparable<Student>{
    ....
    @Override
    public int compareTo(Student o) {
        return this.age-o.age;//升序
    }
}

java.util Comparator<T> : 比较器接口。

抽象方法:

int compare( T o1, T o2 ) 比较其两个参数的大小顺序。

比较器接口的使用场景:

1. Arrays.sort() : static <T> void sort( T[] a, Comparator c)

2. Collections 集合工具类 : void sort(List<T> list, Comparator<> c) 根据指定的比较器给集合中的元素进行排序。

3. TreeSet 集合 : 构造方法 TreeSet( Comparator c )

补充 : 在后面我还会介绍JDK1.8 的新特性(Lambda 函数式代码优化) 进行优化此类接口

ArrayList<String> list = new ArrayList<String>();
        list.add("cba");
        list.add("aba");
        list.add("sba");
        list.add("nba");
        //排序方法  按照第一个单词的降序
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                int rs = o2.getCj() - o1.getCj();
                return rs==0 ? o1.getAge()-o2.getAge():rs;
//                return o2.charAt(0) - o1.charAt(0);
            }
        });
        System.out.println(list);

Comparable 和 Comparator 区别:

Comparable : 对实现了它的类进行整体排序。

Comparator : 对传递了此比较器接口的集合或数组中的元素进行指定方式的排序。

以上就是JavaSE常用类及方法的介绍（附代码）的详细内容，更多请关注php中文网其它相关文章！