Java基础 -- Java基本类（部分）

常用类

1. String类

1. StringStringBuffer,StringBuilder区别

   • String:不可变，重新赋值改变的是内存地址，频繁拼接字符串会给内存地址带来极大负担

   • StringBuffer:可变，多线程操作字符缓冲区下操作大量数据

   • StringBuilder:可变，单线程操作字符缓冲区下操作大量数据

     返回类型	方法	说明
     char	charAt(int index)	返回指定索引处的 char 值
     boolean	equals(Object anObject)	比较此字符串与指定的对象
     boolean	equalsIgnoreCase(String anotherString)	将此 String 与另一个 String 进行比较，不考虑大小写
     boolean	endsWith(String suffix)	测试此字符串是否以指定的后缀结束
     boolean	startsWith(String prefix)	测试此字符串是否以指定的前缀开始
     int	indexOf(String str)	返回第一次出现的指定子字符串在此字符串中的索引
     int	length()	返回此字符串的长度
     String	replace(char oldChar, char newChar)	返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 而生成的
     String[]	split(String regex)	根据给定的正则表达式的匹配来拆分此字符串
     String	substring(int beginIndex)	返回一个新的字符串，它是此字符串的一个子字符串
     String	substring(int beginInde, int endIndex)	返回一个新字符串，它是此字符串的一个子字符串
     String	toLowerCase()	使用默认语言环境的规则将此 String 中的所有字符都转换为小写
     String	toUpperCase()	使用默认语言环境的规则将此 String 中的所有字符都转换为大写
     String	trim()	返回字符串的副本，忽略前导空白和尾部空白

2. 包装类

包装类属引用类型，初始值为null

原生类	包装类
int	Integer （唯一一个可以修改缓存范围的包装类）
short	Short
long	Long
byte	Byte
float	Float
double	Double
boolean	Boolean
char	Character

1. 为什么会存在包装类？

   • 包装类中有许多内置方法
   • 集合泛型必须是包装类
   • 序列化：包装类实现了Serializable接口

2. 包装类转原生类

   返回值	方法名	类转
   byte	byteValue()	Integer-->byte
   double	doubleValue()	-->double
   float	floatValue()	-->float
   int	intValue()	-->int
   long	longValue()	-->long
   static int	parseInt(String s)	String-->int
   String	toString()	-->String
   static Integer	valueOf(String s)	String-->Integer

       public static void main(String[] args) {
           //定义一个引用类
           Integer i = new Integer("4543413541");
           //intValue()转换成int类型
           int i1 = i.intValue();
           String i2 = Integer.toString(i);
           //通过parseInt()方法
           int i3 = Integer.parseInt(i2);
           //通过valueOf()方法再自动拆箱
           int i4 = Integer.valueOf(i2);
           System.out.println("i3:"+i3);
           System.out.println("i4:"+i4);
       }
   

3. 拆装箱

   import java.util.ArrayList;
   import java.util.List;
   
   public class Demo2 {
       public static void main(String[] args) {
           /*拆装箱
               1.为什么自动拆装箱？
                   (1)这是程序编译阶段完成，与程序运行无关
                   (2)减少程序员的编码
            */
           //自动装箱
           int i = 1;
           Integer i1 = i;
           //手动装箱
           Integer i2 = new Integer(i1);
           System.out.println("int类型："+i);
           System.out.println("自动装箱："+i1);
           System.out.println("手动装箱："+i2);
   
           //自动装箱
           int i3 = i1;
           //手动装箱
           int i4 = i2.intValue();
           System.out.println("自动装箱："+i3);
           System.out.println("手动装箱："+i4);
   
           //2.自动装箱 集合
           List<Integer> list = new ArrayList<>();
           for (int j = 0; j < 50; j++) {
               list.add(j);
           }
           System.out.println(list.toString());
           //反编译
           List<Object> list1 = new ArrayList<>();
           for (int j = 0; j < 50 ; j++) {
               list1.add(Integer.valueOf(j));
           }
           System.out.println(list1.toString());
   
           /*3.Integer取值范围在-128~127
               该范围内赋值会储存在IntegerCache中，再次赋值不会创建新的对象，可直接获取
               超过该范围，再次赋值会重新创建对象
            */
           Integer in1 = 128;
           Integer in2 = 128;
           System.out.println(in1==in2);//false
           Integer in3 = 127;
           Integer in4 = 127;
           System.out.println(in3==in4);//true
       }
   }
   

3. 日期类

1. Date类

   import java.text.SimpleDateFormat;
   import java.util.Date;
   
   public class DateDemo {
       public static void main(String[] args) {
           Date d = new Date();
           SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
           String str = sdf.format(d);
           System.out.println(str);
           //String-->Date
           try {
               Date d1 = sdf.parse(str);
               System.out.println(d1);
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
   }
   

2. Calendar类

   import java.util.Calendar;
   
   public class CalDemo {
       public static void main(String[] args) {
           Calendar c = Calendar.getInstance();
           System.out.print(c.get(Calendar.YEAR)+"-");
           System.out.print(c.get(Calendar.MONTH)+"-");
           System.out.print(c.get(Calendar.DAY_OF_MONTH)+"	");
           System.out.print(c.get(Calendar.HOUR_OF_DAY)+":");
           System.out.print(c.get(Calendar.MINUTE)+":");
           System.out.println(c.get(Calendar.SECOND));
       }
   }
   

3. Timer类

   import java.text.SimpleDateFormat;
   import java.util.Date;
   import java.util.Timer;
   import java.util.TimerTask;
   
   public class TimerDemo {
       public static void main(String[] args) {
           //TimerTask 一直输出时间
           Timer t = new Timer();
           MyTask m = new MyTask();
           t.schedule(m,0,1000);
       }
   }
   
   //自定义一个时间类继承TimerTask
   class MyTask extends TimerTask{
       public void run(){
           SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
           System.out.println(sdf.format(new Date()));
       }
   }
   

4.枚举类

package com.wang.commonclasses;

public class EnumDemo {
    public static void main(String[] args) {
        int i = 0;
        if (i != 0){
            System.out.println(Result.SUCCESS);
        }else{
            System.out.println(Result.Fail);
        }
    }
}

/*枚举格式
enum <枚举类型名>{
    <枚举元素表>
}
 */
enum Result{
    //枚举必须大写
    SUCCESS,Fail
}

5.Random类

返回一个伪随机数

import java.util.Random;

public class RandomDemo {
    public static void main(String[] args) {
        Random r = new Random();
        int i = r.nextInt(100);
        System.out.println(i);
    }
}

6.Math类

Math类提供了一序列基本数学运算和几何函数的方法

Math类时final类，所有成员变量和成员方法都是静态的

常用属性和方法：

public class MathDemo {
    public static void main(String[] args) {
        //静态常量
        System.out.println(Math.PI);
        //静态方法
        double a = 4;
        double b = 2;
        //a的b次方
        System.out.println(Math.pow(a,b));//16.0
        //计算a的平方根
        System.out.println(Math.sqrt(a));//2.0
        //绝对值
        int c = -1;
        System.out.println(Math.abs(c));//1
        //向上取整 向下取整 四舍五入
        double d = Math.PI;
        System.out.println(Math.ceil(d));//4.0
        System.out.println(Math.floor(d));//3.0
        System.out.println(Math.round(d));//3.0
        //较大值,较小值
        System.out.println(Math.max(a,b));
        System.out.println(Math.min(a,b));
        //返回带正号的double值
        double e = Math.random();
        System.out.println(e);
    }
}

7.Runtime类

1. getRuntime()：该方法用于返回当前应用程序的运行环境对象。

2. exec(String command)：该方法用于根据指定的路径执行对应的可执行文件。

import java.io.IOException;

public class RuntimeDemo {
    public static void main(String[] args) throws IOException, InterruptedException {
        Runtime runtime = Runtime.getRuntime();
        //打开记事本
        Process p = runtime.exec("C:\Windows\notepad.exe");
        //等待3s
        Thread.sleep(3000);
        //销毁程序
        p.destroy();
    }
}

8.System类

package com.wang.commonclasses;

public class SystemDemo {
    public static void main(String[] args) {
        int[] a = {1,2,3,4};
        int[] b = new int[5];
        /*1.arraycopy()
            源码：public static native void arraycopy(Object src,  int  srcPos, Object dest, int destPos,int length);
            参数：
                src：要复制的数组(源数组)
                srcPos：复制源数组的起始位置
                dest：目标数组
                destPos：目标数组的下标位置
                length：要复制的长度
         */
        System.arraycopy(a,1,b,3,2);
        for (int i = 0; i < b.length ; i++) {
            if (i == 0){
                System.out.print("[");
            }
            if (i == b.length-1){
                System.out.println(b[i]+"]");
            }else {
                System.out.print(b[i]+",");
            }
        }

        /*2.exit()方法
            源码：System.exit(int status)
            主要是调用Runtime.getRuntime().exit(status),可能swing开发会使用System.exit(0).
            退出程序。其中status的值为0代表正常退出，非零代表异常退出。
         */
        try {
            Runtime runtime = Runtime.getRuntime();
        } catch (Exception e) {
            System.exit(1);
        }

        /*3.gc()方法
            请求系统进行垃圾回收
            垃圾回收时，会先调用finalize()方法，释放非java资源
         */
        System.gc();//主要是回收对象

        /*4.currentTimeMillis()方法
            以毫秒为单位返回从1970年1月1日午夜到当前时间的毫秒数
         */
        System.out.println(System.currentTimeMillis());
    }
}