System类- Math类- Biginteger类- Bigdecimal类- 包装类(Wrapper Class）- Scanner类-String类

目录

System类

Math类

BigInteger

Bigdecimal类

包装类（Wrapper Class）

Scanner类

String类

注意事项：设计一个类的时候，不要将类名设计得和jdk提供的类名一样

System类

属性：

     1.err：获取标准的输出流（打印错误信息）

      System.err.println("错误信息");

     2.out：标准的输出流，打印任意信息

      System.out.println("输出信息");

     3.in：获取标准的输入流，可以获取控制台输入的信息

       System.in; // 一般配合scanner使用，用来在控制台输入数据

方法：

1. currentTimeMillis( )：获取当前时间，以毫秒来表示，1000毫秒 == 1秒

   作用：测试代码的运行时间

      long start = System.currentTimeMillis(); // 程序开始时间
      long end = System.currentTimeMillis(); // 程序结束时间
      System.out.println("程序运行时间:" + (end - start) + "毫秒"); // 打印程序运行所需时间

     2.exit(0) 终止当前运行的java虚拟机

       System.exit(0); // 结束JVM

     3.arraycopy(Object src, int srcpos, Object dest, int destPos, int length)

作用：将指定原数组中的数组从指定位置复制到目标数组的指定位置。（相当于替换）

        int[] nums = {1, 2, 3, 4, 5};
        System.out.println(Arrays.toString(SystemDemo.remove(nums, 2, 3)));
    }
    //  设计一个方法删除一个数组中指定范围的元素
    public static int[] remove(int[] nums, int start, int end){
        int[] newArr = new int[nums.length - (end - start)]; // 新数组的长度
        System.arraycopy(nums, 0 , newArr, 0, start);  // 需要删除的下标元素的之前的元素
        System.arraycopy(nums, end, newArr,start,nums.length - end); // 从删除的下标的元素结束的位置开始赋值给新数组
        return newArr;
    }

Math类

作用：封装了一些数学常用的方法

属性（常量）：

1. E：表示2.71

2. PI：表示3.14

//        System.out.println(Math.E);
//        System.out.println(Math.PI);

方法：

1. random()：产生1个范围在0,1之间的随机数，数据类型是double

     double random = Math.random();  // 范围0 - 1 不会取到0 & 1
     System.out.println(random);
//  如果要改变随机数的整数部分的范围，整数部分要变成多大，就乘那个数
     double v = Math.random() * 100;
     System.out.println(v); // 打印整数部分的范围是0 - 99
//  将这个随机数变为整数：使用数据类型向下转换
     int num = (int)(Math.random() * 10);  // 注意运算符优先级，括号优先级最高
     System.out.println(num); // 打印范围0-10包含0 

2. max(),min()：获取两个数中最大或最小

     int max = Math.max(10, 34);
     System.out.println(max);   // 输出34
     int min = Math.min(10, 34); 
     System.out.println(min); // 输出10

3. ceil()：向上取值（天花板）

     double ceil = Math.ceil(3.000000001);
     System.out.println(ceil); // 打印输出4

4. floor():向下取值（地板）

     double floor = Math.floor(3.9999999999);
     System.out.println(floor); // 打印输出3

5. round():四舍五入

     long round = Math.round(3.413);  // 主要看小数点后面的一位
     System.out.println(round); // 打印输出3 

BigInteger

作用：使用整数的范围超过了long，就用BigInteger

注：

1. Number：是数值类型的父类

2. Comparable：自然比较器的接口：对对象比较大小

用法：

1. 构造方法：BigInteger(String val) 将BigInteger的十进制字符串表示形式转换为BigInteger。（ val必须是纯数字的字符串）

   // 创建BigInteger对象 
   BigInteger bi = new BigInteger("1214321453254356465467576576876867876876");
   BigInteger one = BigInteger.TEN; // 创建一个对象赋值为10

2. 常用的方法：加 减 乘 除

   • add(BigInteger a):做加法

   BigInteger sum = bi.add(one);  // 使用对象bi调用方法add跟里面的参数相加
   System.out.println(sum);

   • subtract(BigInteger val) :做减法

   BigInteger subtract = bi.subtract(one); // 使用对象bi调用方法subtract跟里面的参数相减
   System.out.println(subtract);

   • multiply(BigInteger val) :做乘法

   BigInteger multiply = bi.multiply(one); // 使用对象bi调用方法multiply跟里面的参数相乘
   System.out.println(multiply);

   • divide(BigInteger val):做除法

   BigInteger divide = bi.divide(new BigInteger("2"));  // 使用对象bi调用方法divide跟里面的参数相除 除法比较特殊
   System.out.println(divide);

Bigdecimal类

作用：BigDecimal表示小数位可以精确到你想要的位数

使用场景：只要跟钱相关一般都需要使用

构造方法：BigDecimal(String val) 将BigDecimal的字符串表示 BigDecimal转换为 BigDecimal （val是纯数字，带小数点）

BigDecimal bd1 = new BigDecimal("35.1142353"); // 参数必须有小数点

常用的方法：加 减 乘 除

包装类（Wrapper Class）

包装类：将基本数据类型，包装为一个类

基本数据类型：8个

1. byte的包装类是:Byte

2. short的包装类是:Short

3. int的包装类是:Integer

4. long的包装类是:Long

5. float的包装类是:Float

6. double的包装类是:Double

7. char的包装类是:Character

8. boolean的包装类:Boolean

作用：

1. 使用包装，默认都是null

2. 将字符串类型数据转换为对应基本数据类型

装箱&拆箱：

1. 装箱：将基本类型变为包装类

2. 拆箱：将包装类装换为基本类型

Integer类：

1. 常量

2. 构造方法

   • Integer(int value)：构造一个新分配的 Integer对象，该对象表示指定的 int值。 现在有了自动装箱，就不用手动去new了

     Integer i = new Integer(123); // 手动将int类型数字装箱为Integer类型 打印123

     Integer i = 123; // 自动装箱

     int num = i.intValue( ); // 将包装类手动拆箱 调用intValue()方法

     int num2 = i; // 自动拆箱

   • Integer(String s)： 构造一个新的 Integer的对象，表示 int由指示值 String参数。

     Integer i2 = new Integer("121"); // 手动将字符串121++

     装箱为Integer 打印121

3. 方法

   • parseInt(String s) ：将字符串直接转换为int类型

   • parseDouble(String s)：将字符串直接转换为double类型

   • 其他类型同理 ， 不过character特殊，不能将字符串转换成字符

     int num3 = Integer.parseInt("123"); // 打印123 将一个字符串转换成int类型

     double num4 = Double.parseDouble("234"); // 打印输出234.0 将一个字符串转换成double类型

Character类：

1. isDigit(char ch) 确定指定的字符是否是数字。

   char[] chars = {'a','3','D','6','t','7','8','9'}; // 声明一个char类型的数组
   // 统计chars数组中数字的个数
   int count = 0; // 计数器，统计数字的个数
   for (char c : chars) {  // 增强for循环，将每个字符取出来赋给变量c
       if (Character.isDigit(c)) { // 判断c字符是否为数字
           count++;
       }
   }
   System.out.println(count);  // 打印个数

2. isLetter(char ch) 确定指定的字符是否是一个字母。 同上案例，只是变成了判断是否为字符

享元模式：整型的包装

解释： jvm在常量池创建对象，每个整型都有256个对象（-128-127） 只用你使用自动装箱，并且你的数值在-128-127内，就会使用享元模式 （意思就是当创建对象的数值在这个256个对象之内，就会从常量池中创建对象，这样的话值一样，地址就会一样，但是如果是new出来创建的话，地址就会不同）

Integer a = 128; // 创建一个Integer类型的变量
Integer b = 128;
System.out.println(a == b);  // 打印false 由于数值超过了127，不会使用享元模式 

Scanner类

概念：文本扫描器

作用：获取在控台输入文本信息

// 1、创建文本扫描器
Scanner sc = new Scanner(System.in);
// 获取输入的内容，获取的是int类型的数字，nextInt() 是什么类型就使用什么类型 如：nextDouble()获取double类型的值
// next():获取单个字符串  nextLine():获取多个字符串

String类

概念：字符串的类，String底层实现使用final修饰的字节数组来实现的，新建一个String的对象，这个对象里面就有一个final修饰字节数组，这个数组用装字符串的值

如：

String s = "abc"; // 创建一个String类型的变量

final byte[] bytes = {a,b,c} // jvm就会在常量池创建一个数组 一开始是char[]类型的，后面为了节省空间，改成了byte[]

String s2 = "abc"; // 再创建一个String类型的变量

System.out.print(s == s2) // 打印输出为true 说明他们的地址相等

String s3 = "ab";
String s4 = "a" + "b"; // 拼接的是常量，"ab" jvm会将他们自动拼接起来 所以地址相等
System.out.print(s3 == s4) // 打印true 
    
// 但是如果使用变量进行拼接，地址就会发生变化
String s4 = s3 + "c"; // 使用变量拼接
String s5 = "abc";
System.out.println(s4 == s5); // 打印false   由于拼接变量s3的时候，底层会自动在堆中创建一个新的地址，所以跟s5引用的常量池中的地址不同

常用方法：

1. char charAt(int index) 返回 char指定索引处的字符 (不能超过下标范围)

String str = "abc";  // 创建一个String类型的变量  注意数据类型必须是String类型
char c = str.charAt(0); // 变量str是String类型的，所以可以调用String类的方法
System.out.println(c);  // 打印输出a

2. String concat(String str) 将指定的字符串连接到该字符串的末尾 ( 效果等同于：+)

String st = "abc";  // 创建一个String类型的变量st
String st1 = st.concat("ccc"); 
System.out.println(st1); // 打印输出abcccc

3. boolean contains(CharSequence s) 判断当前对象是否包含连续的参数s (s可以是以下三个子类的对象)

CharSequence接口，包含下面子类：String、StringBuffer、StringBuilder

String str0 = "abc";
boolean ab = str0.contains("ab");  // "ab"是string类型的，这里由于string实现了CharSequence接口，所以可以使用
System.out.println(ab); // 打印输出true

4. boolean endsWith(String suffix) 判断当前字符串是否以指定的后缀suffix结尾 （参数必须连续）

boolean startsWith(String prefix) 判断当前字符串是否以指定的前缀prefix开头（参数必须连续）

String name = "不分手的恋爱.mp3";
boolean b = name.endsWith(".avi");
boolean c = name.startsWith("不分手");
System.out.println(b);  // 打印输出false
System.out.println(c);  // 打印输出true

5. void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 旧数组开始下标 旧数组结束下标 新数组 新数组开始的下标

char[] chars = new char[10]; // 创建一个char类型的数组
String s = "abcdefghij"; 
s.getChars(1,5,chars,0);   
System.out.println(Arrays.toString(chars)); // [b, c, d, e,  ,  ,  ,  ,  ,  ]

6. int indexOf(String s) 返回s第一次在当前对象str中出现的索引 -1 表示没有找到（注意：这里s必须也是匹配连续的字符串）

int indexOf(String s, int fromIndex) 返回s在当前对象指定下标fromIndex后第一次出现的索引

String s2 = "abc23432abc23423bc";
int bc = s2.indexOf("bc");
int bc = s2.indexOf("bc", 5); // 从第5个开始找
System.out.println(bc);  // 打印输出1

7. int lastIndexOf(String str) 返回指定子字符串最后一次出现的字符串中的索引。

int lastIndexOf(String str, int fromIndex) 返回指定子字符串的最后一次出现的字符串中的索引，从指定索引开始向前搜索。

String str1 = "owijdfjiwjjw";
int index = str1.lastIndexOf("w");  
System.out.println(index); // 打印输出1 
int index = str1.lastIndexOf("w",10);
System.out.println(index); // 打印输出9  跳过了最后一个w，从下标10的地方向前搜索

8. boolean isEmpty() 当 length()为 0时，返回 true 。

String a = "";
boolean empty = a.isEmpty();  
System.out.println(empty);  // 打印输出true
 String str2 = null; 
str2.isEmpty(); // 空对象 NullPointerException:

9. int length() 返回此字符串的长度。

String g = "232df23";
System.out.println(g.length()); // 打印输出7

10. String replace(CharSequence target, CharSequence replacement) 将当前字符串中的target替换为replacement,通常用来和谐用语

父接口：CharSequence 接口的实现类：String、StringBuffer、StringBuilder

String  str4 = "abc342354dsfsdf436546";
String str6 = str4.replace('5', '五');   // 将字符'5'元素替换为五
String str6 = str4.replace("54","五四"); // 将元素"54"替换为五四
System.out.println(str6);

11. String[] split(String regex) 将当前字符串对象按照给定的正则表达式regex分割为String[]

String str = "172.168.11.65;192.168.11.66;172.168.11.69;169.168.11.169;";
String[] split = str.split(";");// 通过;将str分割成几个字符串
for (String s : split) {
    System.out.println(s);
}

12. CharSequence subSequence(int beginIndex, int endIndex) 从当前字符串中beginIndex和endIndex之间截取子串（含头不含尾）

String str7 = "123456789";
CharSequence charSequence = str7.subSequence(1, 4);
System.out.println(charSequence); // 打印输出234

13. String substring(int beginIndex) 从当前字符串中截取beginIndex到最后的子串

String substring(int beginIndex, int endIndex) 从当前字符串中beginIndex和endIndex之间截取子串（含头不含尾）

String str8 = "123456789";
System.out.println(str8.substring(1)); // 打印输出23456789
System.out.println(str8.substring(0, 3)); // 打印输出123 等于是下标012

14. char[ ] toCharArray() 将此字符串转换为新的字符数组 （方便遍历当前所有的字符）

String str9 = "s2432g";
char[] chs = str9.toCharArray(); // chs中保存的是字符串中的每一个字符
    for (char ch : chs) {
        System.out.println(ch);  
}

15. String toUpperCase() 将此字符转换为全大写 一般用于验证码

String toLowerCase() 将此字符转换为全小写 一般用于验证码

String str10 = "abc";
System.out.println(str10.toUpperCase()); // 打印输出 ABC
System.out.println("ABC".toLowerCase()); // 打印输出 abc

16. String trim() 将当前字符串对象中字符前面和后面的空格去除 用了避免用户的一些不当输入

str = "     asdlkjfal       jfdaklfj        dsalkj      ";
String trim = str.trim();
System.out.println(trim); // 打印输出asdlkjfal      jfdaklfj        dsalkj  清除了字符串整体的前面和后面的空格

17. static String valueOf(Object obj) 将其他类型转换为String对象 还有2个方法 + 和 toString( ) 效率最高

String s = String.valueOf(10);

帮助记忆：包装类，基本数据类型，String类之间的相互转换图解：