JavaSE经常使用类及要领的引见（附代码）【JAVA教程】,JavaSE

本篇文章给人人带来的内容是关于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类中供应许多成员常量，代表给定的日历字段：

字段值	寄义
YEAR	年
MONTH	月（从0最先，能够+1运用）
DAY_OF_MONTH	月中的天（几号）
HOUR	时（12小时制）
HOUR_OF_DAY	时（24小时制）
MINUTE	分
SECOND	秒
DAY_OF_WEEK	周中的天（周几，周日为1，能够-1运用）

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要领

参数序号	参数称号	参数范例	参数寄义
1	src	Object	源数组
2	srcPos	int	源数组索引肇端位置
3	dest	Object	目的数组
4	destPos	int	目的数组索引肇端位置
5	length	int	复制元素个数

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经常运用类及要领的引见（附代码）的细致内容，更多请关注ki4网别的相干文章！