Java基础：常用类学习笔记

Java常用类

基本数据类型的包装类

Java是面向对象的语言，但并不是“完全面向对象”的，如基本数据类型就不是对象。Java中的基本数据类型没有方法和属性，而包装类就是为了让这些拥有方法和属性，实现对象化交互。如：将数据类型存储到Object[]数组或集合中的操作等等。 为了解决不足，java在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的统称为包装类（Wrapper Class）。

基本数据类型 包装类
byte Byte
boolean Boolean
short Short
char Character
int Integer
long Long
folat Folat
double Double

数值型包装类都继承至Number，而字符型和布尔型继承至Object。

基本数据和包装类之间的转换

装箱：基本数据类型转换为包装类；拆箱：包装类转换为基本数据类型。包装类对象的初始值为null（是一个对象）。

public class WrapperDemo1 {
    public static void main(String[] args){
        //1.自动装箱
        int t1=1;
        Integer t2=t1;
        //2.手动装箱
        Integer t3=new Integer(t1);
        System.out.println("int类型t1="+t1);
        System.out.println("自动装箱，Integer类型对象t2="+t2);
        System.out.println("手动装箱，Integer类型t3="+t3);

        //1.自动拆箱
        int t4=t2;
        //2.手动拆箱
            //通过intValue()方法返回int值，还可以利用其他方法装换为其他类型
        int t5=t2.intValue();
        System.out.println("自动拆箱,int型t4="+t4);
        System.out.println("手动拆箱,int型t5="+t5);
    }
}

基本数据类型和包装类的转换

  • Integer.toString(): 将整型转换为字符串。
  • Integer.parseInt(): 将字符串转换为int类型。
  • valueOf(): 把字符串转换为包装类然后通过自动拆箱。
public class WrapperDemo2 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //基本数据类型转换为字符串
        int t1=12;
        String t2=Integer.toString(t1);
        System.out.println("int转换为String："+t2);
        //字符串转换为基本数据类型
        //通过paerInt方法
        int t3=Integer.parseInt(t2);
        //通过valeOf,先把字符串转换为包装类然后通过自动拆箱
        int t4=Integer.valueOf(t2);
        System.out.println("t3:"+t3);
        System.out.println("t4:"+t4);
    }
}

Java为了提高拆装箱效率，在执行过程中提供了一个缓存区（对象池）【类似于常量数组】，如果传入的参数是，-128<参数<127会直接去缓存查找数据，如果有久直接产生，如果没有就隐式调用new方法产生。

包装类的比较

public boolean equals(Object anObject): 如果给定对象与字符串相等，则返回 true；否则返回 false。

public interface Comparator: 此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序。包装类实现了此接口。

public int compareTo( NumberSubClass referenceName ): 该方法用于将 Number及其子类的对象与方法的参数进行比较，两个不同类型的数据不能用此方法来比较。 参数referenceName可以是一个 Byte, Double, Integer, Float, Long 或 Short 类型的参数。

a.compareTo(b) 返回值 排序
a < b 负整数 升序
a = b 0 不变
a > b 正整数 降序 
public class WrapperDemo3 {
 public static void main(String[] args) {
        //简写
        Integer i2 = 20;
        Integer i3 = 10;
        System.out.println(i2.equals(i3));
        System.out.println(i2.compareTo(i3));
        /*打印：
        false
        1 */
    }
}

java.lang.String 类

String类在java.lang包中，java使用String类创建一个字符串变量，字符串变量属于对象。String类对象创建后不能修改，赋值后将会生成新的对像来存放新的内容，原先的对象依旧在内存中，但是s不在指向它，那么这个对象就会成为垃圾内存，在某一个特定的时刻有Java虚拟机回收。

String字符串变量的创建：

  • 声明：String 变量名;
  • 声明并初始化：String 变量名="初始值";
String str;
String str = "字符串";

String常用方法：

  • int length(): 返回值为 int 类型。得到一个字符串的字符个数（中、英、空格、转义字符皆为一个字符，计入长度）
String a="矜君99 \t\n";
int l = a.length();
System.out.println(l);
//打印：7
  • char charAt(int index) : 返回值为 char 类型。从字符串中取出指定位置的字符
String str="矜君99";
char c = str.charAt(2);  
System.out.println("指定字符为：" + c); //打印：指定字符为：9
  • char toCharArray(): 返回值为 char 数组类型。将字符串变成一个字符数组
String str="矜君99";
char c[] = str.toCharArray(); 
for (int i = 0; i < c.length; i++){
    System.out.print(c[i]);
}//打印：矜君99
  • int indexOf(String str) : 返回指定子字符串第一次出现的字符串内的索引。
  • int indexOf(String str, int fromIndex) : 返回指定子串的第一次出现的字符串中的索引，从指定的索引开始。
 public static void main(String[] args) {
        String a="等什么君唱了什么新歌";
        int i1 = a.indexOf("什");
        int i2 = a.indexOf("么",3);
        System.out.print(i1+" "+i2);
    }//打印：1 7
  • String substring(int beginIndex,int endIndex): 返回一个字符串，该字符串是此字符串的子字符串。
    public static void main(String[] args) {
        String a = "等什么君唱了什么新歌";
        String b = a.substring(1,3);
        System.out.print(b);
    }//打印：什么
  • boolean startsWith(String): 测试此字符串是否以指定的前缀开始，返回一个布尔值。
  • boolean endsWith(String): 测试此字符串是否以指定的后缀结束，返回一个布尔值。
public static void main(String[] args) {
        String a = "等什么君唱了什么新歌";
        boolean b1 = a.startsWith("等");
        boolean b2 = a.endsWith("歌");
        System.out.print(b1+" "+b2);
    }//打印：true true

java.util.Scanner 类

简单的文本扫描器,可以使用正则表达式解析原始类型和字符串,可以通过该类获取用户输入。

Scanner 类构造方法

  • Scanner(File source): 使用文件类对象构造扫描器。
  • Scanner(InputStream source) : 使用输入流对象构造扫描器。
  • Scanner(Path source): 使用指定路径文件构造扫描器。

Scanner 类常用方法

  • void close(): 关闭扫描器。
  • boolean hasNextXxx(): Xxx可以是Double,Byte,Int等，判断下一个输入项是否是Xxx。
  • boolean hasNext(): 判断是否有下一个输入项。
  • String nextLine(): 获取下一行字符串,包含回车。
  • Xxx nextXxx(): 获取下一个输入,不包含回车。
import java.util.Scanner;
public class Demo1 {
    public static void main(String args[]){
        Scanner sc=new Scanner(System.in);
        //通过标准输入流构造Scanner
        System.out.println("Please input an integer!");
        if(sc.hasNextInt())//如果如果是Int数打印该数字
            System.out.println("The number is "+sc.nextInt());
        else//如果不是打印错误信息
            System.out.println("Input error!");
    }
}

java.lang.Math 类

Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

  • public static int abs(int a): 求绝对值 。
  • public static double ceil(double a) : 向上取整 。
  • public static double floor(double a) : 向下取整 。
  • public static int max(int a,int b) : 返回二者较大值。
  • public static double pow(double a,double b) : 返回a的b次方。
  • public static double random(): 生成0~1之间的随机小数 。
  • public static int round(float a): 四舍五入为整数 。
  • public static double sqrt(double a): 开方运算。
public class MathDemo {
    public static void main(String[] args) {
        System.out.println(Math.abs(-12.7));
        System.out.println(Math.ceil(12.7));
        System.out.println(Math.rint(12.4));
        System.out.println(Math.random());
        System.out.println("sin30 = " + Math.sin(Math.PI / 6));
        // 计算30°的正弦值，参数是用弧度表示的角，即π的六分之一
        System.out.println("cos30 = " + Math.cos(Math.PI / 6));
        // 计算30°的余弦值，这些计算三角函数的方法，其参数和返回值的类型都为double
        System.out.println("tan30 = " + Math.tan(Math.PI / 6));
        // 计算30°的正切值
    }
}/*打印：
$ javac MathDemo.java
$ java MathDemo
12.7
13.0
12.0
0.8011998172263968
sin30 = 0.49999999999999994
cos30 = 0.8660254037844387
tan30 = 0.5773502691896257 */

java.util.Random类

用于产生随机数,可以设置种子。

构造方法

  • public Random(): 以当前时间为种子。
  • public Random(long seed): 指定种子。

常用方法

  • public int nextInt(): 返回一个int数。
  • public int nextDouble(): 返回一个Double数。
  • public int nextInt(int n): 返回一个数t,0<=t 
import java.util.Random;

public class RandomDemo {
    public static void main(String[] args) {
        Random random = new Random();
        //随机生成一个整数 int范围
        System.out.println(random.nextInt());
        //生成 [0,n] 范围的整数  设n=100
        System.out.println(random.nextInt(100 + 1));
        //生成 [0,n) 范围的整数  设n=100
        System.out.println(random.nextInt(100));
        //生成 [m,n] 范围的整数  设n=100 m=40
        System.out.println((random.nextInt(100 - 40 + 1) + 40));
        //随机生成一个整数 long范围
        System.out.print(random.nextLong());
        //生成[0,1.0)范围的float型小数
        System.out.println(random.nextFloat());
        //生成[0,1.0)范围的double型小数
        System.out.println(random.nextDouble());
    }
}/*打印：
677177918
28
14
88
-42585247394659156490.79453605
0.1549074727290829 */

java.lang.System类

System 类提供了以下功能：

  • 标准输入，标准输出和错误输出流；
  • 访问外部定义的属性和环境变量；
  • 加载文件和库的方法；
  • 以及用于快速复制数组的实用方法。

System 类不能被实例化，只可以使用其静态方法。

常用方法

  • public static void arraycopy(Object src,int srcPos, Object dest,int desPos,int length): 从指定的源数组中复制一个数组，从源数组指定的位置开始，到目标数组指定的位置 。
  • public static long currentTimeMillis() : 返回以毫秒为单位的当前时间(从1970年到现在的毫秒数)。
  • public static void exit(int status): 终止当前正在运行的Java虚拟机，status为 0时退出。
  • public static void gc(): 运行垃圾收集器。
  • public static Properties getProperties() : 取得当前系统的全部属性。
  • public static String getProperty(String key): 获取指定键的系统属性。
import java.util.Arrays;

public class SystemDemo {
    public static void main(String[] args) {
        int[] a = {7, 8, 9, 10, 11};
        int[] b = {1, 2, 3, 4, 5, 6};
        //从数组a的第二个元素开始，复制到b数组的第三个位置 复制的元素长度为3
        System.arraycopy(a, 1, b, 2, 3);
        //输出结果
        System.out.println(Arrays.toString(b));
        System.out.println("当前时间：" + System.currentTimeMillis());
        System.out.println("java版本信息：" + System.getProperty("java.version"));
        //运行垃圾收集器
        System.gc();
        //退出
        System.exit(0);
    }
}/* 打印：
[1, 2, 8, 9, 10, 6]
当前时间：1544670501472 */

java.util.Arrays类

Arrays 类包含用于操作数组的各种方法（例如排序和搜索）。还包含一个静态工厂，允许将数组转为 List。

常用方法

  • List asList(T... a): 返回由指定数组构造的 List 。
  • void sort(Object[] a): 对数组进行排序
  • void fill(Object[] a, Object val): 为数组的所有元素都赋上相同的值
  • boolean equals(Object[] a, Object[] a2): 检查两个数组是否相等
  • int binarySearch(Object[] a, Object key): 对排序后的数组使用二分法查找数据
import java.util.Arrays;
import java.util.Random;

public class ArraysDemo {
    public static void main(String[] args) {
        int[] arr = new int[10];
        //将数组元素都设为9
        Arrays.fill(arr, 9);
        System.out.println("fill:" + Arrays.toString(arr));
        Random random = new Random();
        for (int i = 0; i < arr.length; i++) {
            //使用100以内的随机数赋值数组
            arr[i] = random.nextInt(101);
        }
        //重新赋值后的数组
        System.out.println("重新赋值：" + Arrays.toString(arr));
        //将索引为5的元素设为50
        arr[5] = 50;
        //排序
        Arrays.sort(arr);
        //排序后的数组
        System.out.println("sort排序后：" + Arrays.toString(arr));
        //查找50的位置
        int i = Arrays.binarySearch(arr, 50);
        System.out.println("值为50的元素索引："+i);
        //复制一份新数组
        int[] newArr = Arrays.copyOf(arr, arr.length);
        //比较
        System.out.println("equals:"+Arrays.equals(arr, newArr));
    }
}/* 打印：
fill:[9, 9, 9, 9, 9, 9, 9, 9, 9, 9]
重新赋值：[2, 19, 48, 40, 95, 72, 69, 18, 12, 51]
sort排序后：[2, 12, 18, 19, 40, 48, 50, 51, 69, 95]
值为50的元素索引：6
equals:true  */

java.util.Date类

Date 类表示日期和时间，里面封装了操作日期和时间的方法。Date 类经常用来获取系统当前时间。

构造方法

  • Date(): 构造一个 Date 对象并对其进行初始化以反映当前时间
  • Date(long date): 构造一个 Date 对象，并根据相对于 GMT 1970 年 1 月 1 日 00:00:00 的毫秒数对其进行初始化
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateDemo {
    public static void main(String[] args) {
        String strDate, strTime;
        Date objDate = new Date();
        System.out.println("今天的日期是：" + objDate);
        long time = objDate.getTime();
        System.out.println("自1970年1月1日起以毫秒为单位的时间（GMT）：" + time);
        strDate = objDate.toString();
        //提取 GMT 时间
        strTime = strDate.substring(11, (strDate.length() - 4));
        //按小时、分钟和秒提取时间
        strTime = "时间：" + strTime.substring(0, 8);
        System.out.println(strTime);
        //格式化时间
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(formatter.format(objDate));
    }
}/*
打印：
今天的日期是：Wed Dec 12 14:43:15 CST 2018
自1970年1月1日起以毫秒为单位的时间（GMT）：1544596995669
时间：14:43:15
2018-12-12 14:43:15
*/

Date 类的很多方法自 JDK 1.1 开始就已经过时了。

java.util.Calendar类

在早期的 JDK 版本中，Date 类附有两大功能：

  1. 允许用年、月、日、时、分、秒来解释日期。
  2. 允许对表示日期的字符串进行格式化和句法分析。

在 JDK1.1 中提供了 Calendar 类来完成第一种功能，DateFormat类来完成第二项功能。DateFormat 是 java.text 包中的一个类。与 Date 类有所不同的是，DateFormat 类可以接受用各种语言和不同习惯表示的日期字符串。

Calendar 类是一个抽象类，它完成 Date 类与普通日期表示法之间的转换，而我们更多的是使用 Calendar 类的子类 GregorianCalendar 类。它实现了世界上普遍使用的公历系统。当然我们也可以继承 Calendar 类，然后自己定义实现日历方法。

GregorianCalendar 类的构造方法

构造方法 说明
GregorianCalendar() 创建的对象中的相关值被设置成指定时区，缺省地点的当前时间，即程序运行时所处的时区、地点的当前时间
GregorianCalendar(TimeZone zone) 创建的对象中的相关值被设置成指定时区 zone，缺省地点的当前时间
GregorianCalendar(Locale aLocale) 创建的对象中的相关值被设置成缺省时区，指定地点 aLocale 的当前时间
GregorianCalendar(TimeZone zone,Locale aLocale) year - 创建的对象中的相关值被设置成指定时区，指定地点的当前时间

(突然发现用表格写方法更加方便，前面的以后有空再改成表格)

TimeZone 是 java.util包中的一个类，其中封装了有关时区的信息。每一个时区对应一组 ID。类 TimeZone 提供了一些方法完成时区与对应 ID 两者之间的转换。

例如：

//太平洋时区的 ID 为 PST
TimeZone tz0 = TimeZone.getTimeZone("PST")
//getDefault()可以获取主机所处时区的对象
TimeZone tz1 = TimeZone.getDefault()

Locale 只是一种机制，它用来标识一个特定的地理、政治或文化区域获取一个 Locale 对象的构造方法：

//调用Locale类的构造方法
Locale l0 = new Locale(String language)
Locale l1 = new Locale(String language, String country)
Locale l2 = new Locale(String languge, String country, String variant)

//调用Locale类中定义的常量
Locale  l1 = Locale.CHINA

实例：

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class CalendarDemo {
    public static void main(String[] args) {
        System.out.println("完整显示日期时间：");
        // 字符串转换日期格式
        DateFormat fdate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String str = fdate.format(new Date());
        System.out.println(str);

        // 创建 Calendar 对象
        Calendar calendar = Calendar.getInstance();
        // 初始化 Calendar 对象，但并不必要，除非需要重置时间
        calendar.setTime(new Date());

        // 显示年份
        System.out.println("年： " + calendar.get(Calendar.YEAR));

        // 显示月份 (从0开始, 实际显示要加一)
        System.out.println("月： " + calendar.get(Calendar.MONTH));


        // 当前分钟数
        System.out.println("分钟： " + calendar.get(Calendar.MINUTE));

        // 今年的第 N 天
        System.out.println("今年的第 " + calendar.get(Calendar.DAY_OF_YEAR) + "天");

        // 本月第 N 天
        System.out.println("本月的第 " + calendar.get(Calendar.DAY_OF_MONTH) + "天");

        // 3小时以后
        calendar.add(Calendar.HOUR_OF_DAY, 3);
        System.out.println("三小时以后的时间： " + calendar.getTime());
        // 格式化显示
        str = (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS")).format(calendar.getTime());
        System.out.println(str);

        // 重置 Calendar 显示当前时间
        calendar.setTime(new Date());
        str = (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS")).format(calendar.getTime());
        System.out.println(str);

        // 创建一个 Calendar 用于比较时间
        Calendar calendarNew = Calendar.getInstance();

        // 设定为 5 小时以前，后者大，显示 -1
        calendarNew.add(Calendar.HOUR, -5);
        System.out.println("时间比较：" + calendarNew.compareTo(calendar));

        // 设定7小时以后，前者大，显示 1
        calendarNew.add(Calendar.HOUR, +7);
        System.out.println("时间比较：" + calendarNew.compareTo(calendar));

        // 退回 2 小时，时间相同，显示0
        calendarNew.add(Calendar.HOUR, -2);
        System.out.println("时间比较：" + calendarNew.compareTo(calendar));

        // calendarNew创建时间点
        System.out.println((new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS")).format(calendarNew.getTime()));
        // calendar创建时间点
        System.out.println((new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS")).format(calendar.getTime()));
        System.out.println("时间比较：" + calendarNew.compareTo(calendar));
    }
}/*
打印：
完整显示日期时间：
2020-06-07 12:01:42
年： 2020
月： 5
分钟： 1
今年的第 159天
本月的第 7天
三小时以后的时间： Sun Jun 07 15:01:42 UTC 2020
2020-06-07 15:01:42:819
2020-06-07 12:01:42:823
时间比较：-1
时间比较：1
时间比较：0
2020-06-07 12:01:42:823
2020-06-07 12:01:42:823
时间比较：0  
*/

注意：这里会涉及到 calendarNew 与 calendar 的创建时间点，calendarNew 经过增加和减少时间后恢复到原来的时间点，也就是最终比较的是谁先创建好，时间点靠后的大一些，而 calendarNew 创建的时间点只有可能是大于等于 calendar 的，需要根据实际的创建时间点进行比较。

相关

标签