1、 字符串操作——String类

1、 String可以表示一个字符串。

2、 String类实际是使用字符数组存储的。

String类的两种赋值方式：

  1. 一种称为直接赋值：String name = “小白”
  2. 通过关键字new调用String的构造方法赋值：String name = new String(“小白”)

String类的两种赋值分析：

  1. 字符串常量池
  2. String name = new String(“小白”)， 在内存中的分析
  3. String name = “小白”， 在内存中的分析

String类编译期与运行期分析：

  1. 编译期和运行期
  2. 代码示例： 4种情况分析
  1. package com.vince;
  3. /**
  4.  * 
  5.  * @author vince
  6.  * @description
  7.  * String 表示一个字符串，内部使用字符数组实现，不能被继承（最终类），不可变
  8.  */
  9. public class StringDemo {
  11.    public static void main(String[] args) {
  13.       //String 的两种赋值方式，JAVA推荐使用第一种方式
  15.       //1 直接赋值
  16.       String s1 = "你好";  //此时“你好”放在字符串常量池中
  18.       //2 使用new关键字创建对象,new：表示申请内存空间
  19.       ////面试题 问以下代码创建了几个对象? 2个
  20.       String s2 = new String("你好");
  22.       String s3 = "你好";  //直接在常量池中寻找，省内存空间
  24.       System.out.println(s1==s2);//false
  25.       System.out.println(s1==s3);//true
  26.       System.out.println("-----------------");
  28.       //代码示例：4种情况分析:直接赋值字符串连接时，考虑编译期和运行期
  29.       //如果在编译期值 可以被确定，那么就使用已有的对象，否则会创建新的对象
  30.       String a = "a";
  31.       String a1 = a+1;
  32.       String a2 = "a1";
  33.       System.out.println(a1==a2);//false
  35.       final String b = "b";  //b此时是常量
  36.       String b1 = b+1;      //在编译器b1可以被确定
  37.       String b2 = "b1";
  38.       System.out.println(b1==b2);//true
  40.       String c = getC();
  41.       String c1 = c+1;
  42.       String c2 = "c1";
  43.       System.out.println(c1==c2);//false
  45.       final String d = getD();   //方法在运行期才会获得结果
  46.       String d1 = d+1;
  47.       String d2 = "d1";
  48.       System.out.println(d1==d2);//false
  49.    }
  51.    private static String getC(){
  52.       return "c";
  53.    }
  54.    private static String getD(){
  55.       return "d";
  56.    }
  58. }

（1）字符与字符串操作方法

7、常用类库API - 图1

7、常用类库API - 图2

（2）判断是否以指定内容开头或结尾

7、常用类库API - 图3

（3）替换操作

7、常用类库API - 图4

（4）字符串截取操作

7、常用类库API - 图5

（5）字符串拆分操作

7、常用类库API - 图6

（6）字符串查找操作

7、常用类库API - 图7

7、常用类库API - 图8

（7）其它操作方法

7、常用类库API - 图9

  1. import java.util.Arrays;
  3. public class StringDemo2 {
  5.     public static void main(String[] args) {
  7.         String str = " fkwefwfa d6737383 ";
  9.         char c = str.charAt(1);
  10.         System.out.println(c);    //f
  12.         System.out.println(str.toCharArray());    // fkwefwfa d6737383
  14.         char[] cs = {'a','b','c'};
  15.         String s1 = new String(cs);
  16.         System.out.println(s1);    //abc
  18.         String s2 = new String(cs,0,1);
  19.         System.out.println(s2);    //a
  21.         System.out.println(Arrays.toString(str.getBytes()));
  22.         //[32, 102, 107, 119, 101, 102, 119, 102, 97, 32, 100, 54, 55, 51, 55, 51, 56, 51, 32]
  24.         System.out.println(str.replace('w', '*'));    // fk*ef*fa d6737383
  26.         System.out.println(str.replaceAll("\\d", "*"));    // fkwefwfa d*******
  28.         System.out.println(str.substring(0, 4));    //fkw
  30.         System.out.println(Arrays.toString(str.split("d")));    //[ fkwefwfa , 6737383 ]
  32.         System.out.println(str.contains("a"));    //true
  34.         System.out.println(str.indexOf("f"));    //1
  35.         System.out.println(str.lastIndexOf("f"));    //7
  36.         System.out.println(str.isEmpty());    //false
  38.         System.out.println(str.length());    //19
  40.         System.out.println(str.trim());    //fkwefwfa d6737383
  42.         System.out.println(str.concat("*****"));    // fkwefwfa d6737383 *****
  44.         System.out.println(String.valueOf(10));    //10
  45.     }
  47. }

2、字符串操作——StringBuffer类

在实际开发当中， 我们经常会使用到字符串连接的操作， 如果用String来操作， 则使用“ +” 号完成字符串的连接操作。

使用String连接字符串， 代码性能会非常低， 因为String的内容不可改变。

解决这个问题的方法是使用StringBuffer。

StringBuffer常用操作方法

7、常用类库API - 图10

  1. public class StringBufferDemo {
  2.     public static void main(String[] args) {
  3.         String a = "a";
  4.         String b = "b";
  5.         String c = a+b+1;    //会出现5个对象
  6.         System.out.println(c);
  8.         String d = "a"+1+2+3+4+"b";//a1234b //常量相加没有性能问题（编译期进行优化）
  10.         //StringBuffer目的是来解决字符串相加时带来的性能问题(常量与变量)
  11.         //StringBuffer的内部实现采用字符数组，默认数组的长度为16，超过数组大小时，动态扩充的算法是原来长度*2+2
  12.         //所以当我们预知要添加的数据长度时，建议使用带初始化容量的构造方法，来避免动态扩充的次数，从而提高效率
  13.         //带线程锁，故线程安全的，但会影响性能，
  14.         StringBuffer sb = new StringBuffer(32);//带容量的构造（建议）
  15.         sb.append(a).append(b).append(1);
  16.         System.out.println(sb.toString());
  18.         StringBuffer sb2 = new StringBuffer("abc");
  19.         sb2.delete(0, 1);
  20.         System.out.println(sb2);    //bc
  21.     }
  22. }

3、字符串操作——StringBuilder类

StringBuffer的兄弟StringBuilder：

一个可变的字符序列。 此类提供一个与 StringBuffer 兼容的 API， 但不保证同步。 该类被设计用作 StringBuffer 的一个简易替换， 用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。

如果可能， 建议优先采用该类， 因为在大多数实现中， 它比StringBuffer 要快。

JDK1.5以后， 字符串相加原理分析

  1. public class StringBuilderDemo {
  3.    public static void main(String[] args) {
  5.       //面试题 ：StringBuffer与StringBuilder的区别？
  6.       //StringBuffer是线程安全的，性能低，适合在多线程的使用，JDK1.0
  7.       //StringBuilder是线程不安全的，性能高，适合在单线程中使用，这种情况占多大数,在jdk1.5后添加
  8.       //StringBuilder sb = new StringBuilder();
  11.       //字符串相加操作
  12.       //1、多个常量相加没有性能问题 ，在编译期优化
  13.       //2、变量与常量相加，会产生多个垃圾对象
  15.       //String a = "a"+1;
  16.       //String b = a+"b";
  18.       String c = null;
  19.       for(int i=0;i<5;i++){
  20.          c+=i; //每次循环会产生一个StringBuilder对象实现拼接，性能低，最好是手动创建StringBuilder来拼接
  21.       }
  22.       //1、字符串相加，在编译后，会使用StringBuilder来优化代码，实现拼接
  23.    }
  25.     StringBuilder sb3=new StringBuilder();
  26.     sb3.append(1).append(2).append(3);
  27.     System.out.println(sb3);
  29. }

4、程序国际化

（1） 对国际化程序的理解
Internationalization： 国际化程序可以这样理解：

同一套程序代码可以在各个语言环境下进行使用。

各个语言环境下， 只是语言显示的不同， 那么具体的程序操作本身都是一样的， 那么国际化程序完成的就是这样的一个功能。

（2）Locale类

Locale 对象表示了特定的地理、 政治和文化地区。 需要 Locale 来执行其任务的操作称为语言环境敏感的操作， 它使用 Locale 为用户量身定制信息。 例如， 显示一个数值就是语言环境敏感的操作， 应该根据用户的国家、 地区或文化的风俗/传统来格式化该数值。

使用此类中的构造方法来创建 Locale：

  1. Locale(String language)
  2. Locale(String language, String country)

通过静态方法创建Locale：

  1. getDefault()

（3）ResourceBundle类

国际化的实现核心在于显示的语言上， 通常的做法是将其定义成若干个属性文件（文件后缀是*.properties） ， 属性文件中的格式采用“ key=value” 的格式进行操作。

ResourceBundle类表示的是一个资源文件的读取操作， 所有的资源文件需要使用ResourceBundle进行读取， 读取的时候不需要加上文件的后缀。

  1. getBundle(String baseName)
  2. getBundle(String baseName,Locale locale)
  3. getString(String key)

（4）处理动态文本
前面的示例读取的内容都是固定的， 如果现在假设要想打印这样的信息“ 欢迎你，XXX！ ” ， 具体的名字不是固定的， 那么就要使用动态文本进行程序的处理。

进行动态的文本处理， 必须使用java.text.MessageFormat类完成。 这个类是java.text.Format的子类。

  1. package com.vince;
  3. import java.text.MessageFormat;
  4. import java.util.Locale;
  5. import java.util.ResourceBundle;
  6. import java.util.Scanner;
  8. /**
  9.  * 程序国际化
  10.  * 1、Locale
  11.  * 2、Properties文件：属性文件（配置文件），内容以键值对的形式存放（key-value）
  12.  * 3、ResourceBundle工具类，来绑定属性文件，并指定Locale对象，来自动选择使用哪个属性文件，默认将使用与操作系统相同的语言环境。
  13.  *       getString()方法来从属性文件中使用key来获取value
  14.  * 注意，ResourceBundle工具类是只读的
  15.  */
  16. public class I18NDemo {
  18.     public static void main(String[] args) {
  19.         //创建一个本地语言环境对象,该对象会根据参数设置来自动选择与之相关的语言环境
  20.         //参数:语言，地区
  21.         Locale locale_CN = new Locale("zh","CN");
  22.         Locale locale_US = new Locale("en","US");
  23.         //获取当前系统默认的语言环境
  24.         Locale locale_default = Locale.getDefault();
  26.         Scanner input = new Scanner(System.in);
  27.         //用于绑定属性文件的工具类(参数：属性文件的基本名（就是前缀,比如，info）)
  28.         //ResourceBundle 工具类
  29.         ResourceBundle r = ResourceBundle.getBundle("com.vince.info",locale_CN);
  30. //        ResourceBundle r = ResourceBundle.getBundle("com.vince.info",locale_US);
  31.         System.out.println(r.getString("system.name"));
  32.         System.out.println(r.getString("input.username"));
  33.         String username = input.nextLine();
  34.         System.out.println(r.getString("input.password"));
  35.         String password = input.nextLine();
  37.         if("admin".equals(username) && "123".equals(password)){
  38.             System.out.println(r.getString("login.success"));
  39.             String welcome = r.getString("welcome");
  40.             //动态文本格式化
  41.             welcome = MessageFormat.format(welcome, username);
  42.             System.out.println(welcome);
  43.         }else {
  44.             System.out.println(r.getString("login.error"));
  45.         }
  47.     }
  49. }
  50. /*
  51. 员工管理系统
  52. 输入用户名：
  53. admin
  54. 输入密码：
  55. 123
  56. 登录成功
  57. 欢迎你，admin
  59. EMP Manager System
  60. Input UserName:
  61. admin
  62. Input Password:
  63. 123
  64. Login Success!
  65. welcome,admin
  66. */

info_zh_CN.properties

  1. system.name=\u5458\u5DE5\u7BA1\u7406\u7CFB\u7EDF
  2. input.username=\u8F93\u5165\u7528\u6237\u540D\uFF1A
  3. input.password=\u8F93\u5165\u5BC6\u7801\uFF1A
  4. login.success=\u767B\u5F55\u6210\u529F
  5. login.error=\u767B\u5F55\u9519\u8BEF
  6. welcome=\u6B22\u8FCE\u4F60\uFF0C{0}

info_en_US.properties

  1. system.name=EMP Manager System
  2. input.username=Input UserName:
  3. input.password=Input Password:
  4. login.success=Login Success!
  5. login.error=Login Error
  6. welcome=welcome,{0}

7、常用类库API - 图11

5、Math与Random类

（1）Math类

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

使用Math类可以有两种方式：

  1. 直接使用（Math所在的包java.lang为默认引入的包）
  2. 使用 import static java.lang.Math.abs; 静态导入

7、常用类库API - 图12

（2）Random类

Random： 此类的实例用于生成伪随机数流

7、常用类库API - 图13

  1. import static java.lang.Math.floor; //静态导入
  3. import java.util.Random;
  4. public class MathRandomDemo {
  6.     public static void main(String[] args) {
  8.         System.out.println(Math.PI);
  9.         System.out.println(Math.abs(-10));
  10.         System.out.println(Math.round(Math.random()*1000)/1000.0);    //应用random以及round取三位小数
  11.         System.out.println(Math.sqrt(2));
  12.         System.out.println(floor(1.234564));
  14.         Random r = new Random();
  15.         System.out.println(r.nextLong());
  16.         System.out.println(r.nextInt(10));
  17.     }
  19. }
  21. /*
  22. 3.141592653589793
  23. 10
  24. 0.461
  25. 1.4142135623730951
  26. 1.0
  27. 3352128650373644561
  28. 7
  29. */

6、日期操作类

（1）Date类

类 Date 表示特定的瞬间， 精确到毫秒， 也就是程序运行时的当前时间。

Date date = new Date(); // 实例化Date对象， 表示当前时间

（2）Calendar类

Calendar， 日历类， 使用此类可以将时间精确到毫秒显示。

//两种实例化方式

  1. Calendar c = Calendar.getInstance();
  2. Calendar c = new GregorianCalendar();

（3）DateFormat类及子类SimpleDateFormat

  1. package com.vince;
  3. import java.text.DateFormat;
  4. import java.text.SimpleDateFormat;
  5. import java.util.Calendar;
  6. import java.util.Date;
  7. import java.util.GregorianCalendar;
  9. public class DateDemo {
  11.    public static void main(String[] args) {
  13.       Date date = new Date();
  14.       // java.sql.Date sqlDate = new java.sql.Date();
  15.       System.out.println(date);
  17.       // 使用两个构造方法
  18.       // Date(long date) 参数是毫秒
  19.       // Date()
  21.       Calendar c1 = Calendar.getInstance();
  22.       Calendar c2 = new GregorianCalendar();
  24.       int year = c1.get(Calendar.YEAR);
  25.       int month = c1.get(Calendar.MONTH);
  26.       int day = c1.get(Calendar.DAY_OF_MONTH);
  27.       int hour = c1.get(Calendar.HOUR_OF_DAY);
  28.       int minute = c1.get(Calendar.MINUTE);
  29.       int second = c1.get(Calendar.SECOND);
  30.       int millisecond = c1.get(Calendar.MILLISECOND);
  31.       StringBuilder sb = new StringBuilder(50);
  32.       sb.append(year).append("年").append(month).append("月").append(day).append("日").append(hour).append(":")
  33.             .append(minute).append(":").append(second).append(" ").append(millisecond);
  34.       System.out.println(sb.toString());
  36.       DateFormat df = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss SSS");
  37.       String nowDate = df.format(new Date());
  38.       System.out.println(nowDate);
  39.    }
  40. }
  41. /*
  42. Sat Oct 16 23:29:20 CST 2021
  43. 2021年9月16日23:29:20 147
  44. 2021年10月16日 23:29:20 179
  45. */

7、对象比较器Arrays.sort()

对两个或多个数据项进行比较， 以确定它们是否相等， 或确定它们之间的大小关系及排列顺序称为比较。

前面我学习过Arrays.sort方法可实现对象的排序操作：

  1. public static void sort(Object[] a)

（1） Comparable接口：

此接口强行对实现它的每个类的对象进行整体排序。 这种排序被称为类的自然排序， 类的compareTo 方法被称为它的自然比较方法。

（2） Comparator接口：

Comparable接口是要求自定义类去实现， 按照OO原则： 对修改关闭， 对扩展开放。那么如果这个类已经定义好了， 不想再去修改它， 那如何实现比较呢？

Comparator接口： 强行对某个对象collection进行整体排序的比较

Test

  1. import java.util.Arrays;
  3. public class Test {
  5.    public static void main(String[] args) {
  8.       int[] nums = {34,54,22,3,5,6,7,87,9};
  9.       Arrays.sort(nums);
  10.       System.out.println(Arrays.toString(nums)); //[3, 5, 6, 7, 9, 22, 34, 54, 87]
  12.       String[] names = {"jack","tom","菲菲","你好"}; 
  13.       Arrays.sort(names);
  14.       System.out.println(Arrays.toString(names));    //[jack, tom, 你好, 菲菲]
  16.       Cat[] cats = {new Cat("愤愤",1),new Cat("菲菲",4),new Cat("Tom",2)};
  17.       Arrays.sort(cats);
  18.       System.out.println(Arrays.toString(cats));
  19.       //[Cat [name=愤愤, age=1], Cat [name=Tom, age=2], Cat [name=菲菲, age=4]]
  21.       Dog[] dogs = {new Dog("愤愤",1),new Dog("菲菲",4),new Dog("Tom",2)};
  22.       Arrays.sort(dogs,new DogComparator());
  23.       System.out.println(Arrays.toString(dogs));
  24.       //[Dog [name=愤愤, age=1], Dog [name=Tom, age=2], Dog [name=菲菲, age=4]]
  25.    }
  26. }

Cat

  1. /**
  2.  * 自定义对象，要实现比较排序
  3.  * 1、可以实现Comparable的comparaTo方法
  4.  * @author vince
  5.  * @description
  6.  */
  7. public class Cat implements Comparable<Cat>{
  8.    private String name;
  9.    private int age;
  12.    public Cat() {
  13.       super();
  14.    }
  15.    public Cat(String name, int age) {
  16.       super();
  17.       this.name = name;
  18.       this.age = age;
  19.    }
  20.    @Override
  21.    public String toString() {
  22.       return "Cat [name=" + name + ", age=" + age + "]";
  23.    }
  24.    @Override
  25.    public int compareTo(Cat o) {
  26. //    if(this.age<o.age)return -1;
  27. //    if(this.age>o.age)return 1;
  28. //    return 0;
  29.       return this.age-o.age;
  30.    }
  31. }

Dog

  1. public class Dog {
  2.    private String name;
  3.    private int age;
  5.    @Override
  6.    public String toString() {
  7.       return "Dog [name=" + name + ", age=" + age + "]";
  8.    }
  9.    public Dog(String name, int age) {
  10.       super();
  11.       this.name = name;
  12.       this.age = age;
  13.    }
  14.    public Dog() {
  15.       super();
  16.    }
  18. }

DogComparator

  1. import java.util.Comparator;
  3. public class DogComparator implements Comparator<Dog>{
  5.    @Override
  6.    public int compare(Dog o1, Dog o2) {
  7.       return o1.getAge()-o2.getAge();
  8.    }
  10. }

8、对象的克隆

将一个对象复制一份， 称为对象的克隆技术。

在Object类中存在一个clone()方法：

  1. protected Object clone() throws CloneNotSupportedException

如果某个类的对象要想被克隆， 则对象所在的类必须实现Cloneable接口。 此接口没有定义任何方法， 是一个标记接口

Cat

  1. /**
  2.  * 对象需要具备克隆功能：
  3.  * 1、实现Cloneable接口,(标记接口)
  4.  * 2、重写Object类中的clone方法
  5.  * @author vince
  6.  * @description
  7.  */
  8. public class Cat implements Cloneable{
  9.     private String name;
  10.     private int age;
  11.     public String getName() {
  12.         return name;
  13.     }
  14.     public void setName(String name) {
  15.         this.name = name;
  16.     }
  17.     public int getAge() {
  18.         return age;
  19.     }
  20.     public void setAge(int age) {
  21.         this.age = age;
  22.     }
  23.     public Cat(String name, int age) {
  24.         super();
  25.         this.name = name;
  26.         this.age = age;
  27.     }
  28.     public Cat() {
  29.         super();
  30.     }
  31.     //重写Object中的clone方法
  32.     @Override
  33.     protected Object clone() throws CloneNotSupportedException {
  34.         return super.clone();
  35.     }
  36.     @Override
  37.     public String toString() {
  38.         return "Cat [name=" + name + ", age=" + age + "]";
  39.     }
  41. }

Test

  1. package com.vince;
  3. import java.io.IOException;
  5. public class Test {
  7.     public static void main(String[] args) {
  8.         Cat cat = new Cat("喵喵小白",2);
  9.         try {
  10.             Cat newCat = (Cat) cat.clone();
  11.             System.out.println("cat="+cat);
  12.             //cat=Cat [name=喵喵小白, age=2]
  13.             System.out.println("new cat="+newCat);
  14.             //new cat=Cat [name=喵喵小白, age=2]
  15.             System.out.println(cat==newCat);
  16.             //false
  17.         } catch (CloneNotSupportedException e) {
  18.             e.printStackTrace();
  19.         }
  20.     }
  21. }

9、System与 Runtime类

System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。 该类位于java.lang包。

（1）成员变量

System类内部包含in、out和err三个成员变量， 分别代表标准输入流(键盘输入)， 标准输出流(显示器)和标准错误输出流。

（2）成员方法

System类中提供了一些系统级的操作方法

  1. public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
    该方法的作用是数组拷贝， 也就是将一个数组中的内容复制到另外一个数组中的指定位置， 由于该方法是native方法， 所以性能上比使用循环高效。
  2. public static long currentTimeMillis()
    该方法的作用是返回当前的计算机时间， 时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数
  3. public static void exit(int status)
    该方法的作用是退出程序。 其中status的值为0代表正常退出， 非零代表异常退出。 使用该方法可以在图形界面编程中实现程序的退出功能等。
  4. public static void gc()
    该方法的作用是请求系统进行垃圾回收。 至于系统是否立刻回收， 则取决于系统中垃圾回收算法的实现以及系统执行时的情况。
  5. public static String getProperty(String key)
    该方法的作用是获得系统中属性名为key的属性对应的值。
    java.version Java 运行时环境版本
    java.home Java 安装目录
    os.name 操作系统的名称
    os.version 操作系统的版本
    user.name 用户的账户名称
    user.home 用户的主目录
    user.dir 用户的当前工作目录

Runtime类： 每个 Java 应用程序都有一个 Runtime 类实例， 使应用程序能够与其运行的环境相连接。

  1. //获取Java运行时相关的运行时对象
  2. Runtime rt = Runtime.getRuntime();
  3. System.out.println("处理器数量： " + rt.availableProcessors()+" 个");
  4. System.out.println("Jvm总内存数 ： "+ rt.totalMemory()+" byte");
  5. System.out.println("Jvm空闲内存数： "+ rt.freeMemory()+" byte");
  6. System.out.println("Jvm可用最大内存数： "+ rt.maxMemory()+" byte");
  7. //在单独的进程中执行指定的字符串命令。
  8. rt.exec("notepad");
  1. package com.vince;
  3. import java.io.IOException;
  4. import java.math.BigDecimal;
  5. import java.math.BigInteger;
  6. import java.text.DateFormat;
  7. import java.text.SimpleDateFormat;
  8. import java.util.Arrays;
  9. import java.util.Date;
  11. public class SystemRuntimeDemo {
  13.    public static void main(String[] args) {
  15.       System.out.println("向控制台输出");
  16.       System.err.println("出错啦");
  18.       int[] num1 = {1,2,3,4,5,6,7,8};
  19.       int[] num2 = new int[num1.length];
  20.       //参数（源数组，源数组的起始位置 ，目标数组，目标数组的起始位置 ，长度）
  21.       System.arraycopy(num1, 0, num2, 0, num1.length);
  22.       System.out.println(Arrays.toString(num2));
  25.       System.out.println(System.currentTimeMillis());
  26.       Date nowDate = new Date(System.currentTimeMillis());
  27.       DateFormat df = new SimpleDateFormat("HH:mm:ss");
  28.       String now = df.format(nowDate);
  29.       System.out.println(now);
  30.       //退出JVM
  31.       //System.exit(0);
  33.       System.out.println(System.getProperty("java.version"));
  34.       System.out.println(System.getProperty("java.home"));
  35.       System.out.println(System.getProperty("os.name"));
  37.       Runtime rt = Runtime.getRuntime();
  38.       System.out.println("处理器数量：" + rt.availableProcessors()+" 个");
  39.       System.out.println("Jvm总内存数 ："+ rt.totalMemory()+" byte");
  40.       System.out.println("Jvm空闲内存数： "+ rt.freeMemory()+" byte");
  41.       System.out.println("Jvm可用最大内存数： "+ rt.maxMemory()+" byte");
  43.       //在单独的进程中执行指定的字符串命令。 
  44.       try {
  45.          rt.exec("notepad"); //打开记笔本
  46.       } catch (IOException e) {
  47.          // TODO Auto-generated catch block
  48.          e.printStackTrace();
  49.       }
  50.       //加载C、C++编写的类库
  51.       //System.loadLibrary(libname) 
  53.    }
  55. }

10、 数字处理工具类

（1）BigInteger

可以让超过Integer范围内的数据进行运算。

构造方法： public BigInteger(String val)

常用方法：

  1. public BigInteger add(BigInteger val)
  2. public BigInteger subtract(BigInteger val)
  3. public BigInteger multiply(BigInteger val)
  4. public BigInteger divide(BigInteger val)
  5. public BigInteger[] divideAndRemainder(BigInteger val)

（2）BigDecimal

由于在运算的时候， float类型和double很容易丢失精度， 为了能精确的表示、 计算浮点数， Java提供了BigDecimal，不可变的、 任意精度的有符号十进制数。

构造方法： public BigDecimal(String val)

常用方法：

  1. public BigDecimal add(BigDecimal augend)
  2. public BigDecimal subtract(BigDecimal subtrahend)
  3. public BigDecimal multiply(BigDecimal multiplicand)
  4. public BigDecimal divide(BigDecimal divisor)

（3）DecimalFormat：

Java 提供 DecimalFormat类， 帮你用最快的速度将数字格式化为你需要的样子。
例如， 取2位小数。

示例：

  1. double pi=3.1415927; //圆周率
  2. //取一位整数， 结果： 3
  3. System.out.println(new DecimalFormat("0").format(pi));
  4. //取一位整数和两位小数， 结果3.14
  5. System.out.println(new DecimalFormat("0.00").format(pi));
  6. //取两位整数和三位小数， 整数不足部分以0填补， 结果： 03.142
  7. System.out.println(new DecimalFormat("00.000").format(pi));
  8. //取所有整数部分， 结果： 3
  9. System.out.println(new DecimalFormat("#").format(pi));
  10. //以百分比方式计数， 并取两位小数， 结果： 314.16%
  11. System.out.println(new DecimalFormat("#.##%").format(pi));
  1. import java.math.BigDecimal;
  2. import java.math.BigInteger;
  3. import java.text.DecimalFormat;
  4. import java.util.Arrays;
  6. public class Test {
  8.    public static void main(String[] args) {
  10.       //大整数运算
  11.       String val1 = "84567890986544567";
  12.       String val2 = "45097659985495567";
  13.       BigInteger b1 = new BigInteger(val1);
  14.       BigInteger b2 = new BigInteger(val2);
  16.       System.out.println(b1.add(b2));//+
  17.       System.out.println(b1.subtract(b2));//-
  18.       System.out.println(b1.multiply(b2));//*
  19.       System.out.println(b1.divide(b2));// /
  20.       System.out.println(b1.remainder(b2));// %
  22.       System.out.println(Arrays.toString(b1.divideAndRemainder(b2))); // / and %
  25.       String val3 = "5696.698494847898754789";
  26.       String val4 = "6";
  27.       BigDecimal b3 = new BigDecimal(val3);
  28.       BigDecimal b4 = new BigDecimal(val4);
  29.       System.out.println(b3.add(b4));
  30.       System.out.println(b3.subtract(b4));
  31.       System.out.println(b3.multiply(b4));
  32.       System.out.println(b3.divide(b4));
  33.       //System.out.println(b3.scale()-b4.scale());
  36.       double pi=3.1415927;//圆周率  
  37.       //取一位整数，结果：3
  38.       System.out.println(new DecimalFormat("0").format(pi));   
  39.       //取一位整数和两位小数，结果3.14
  40.       System.out.println(new DecimalFormat("0.00").format(pi));
  41.       //取两位整数和三位小数，整数不足部分以0填补，结果：03.142
  42.       System.out.println(new DecimalFormat("00.000").format(pi));
  43.       //取所有整数部分，结果：3
  44.       System.out.println(new DecimalFormat("#").format(pi));
  45.       //以百分比方式计数，并取两位小数，结果：314.16%
  46.       System.out.println(new DecimalFormat("#.##%").format(pi));
  48.       long num = 635463773;
  49.       System.out.println(new DecimalFormat("###,###").format(num));
  51.    }
  53. }
  55. /*
  56. 129665550972040134
  57. 39470231001049000
  58. 3813813993401642148647580426434489
  59. 1
  60. 39470231001049000
  61. [1, 39470231001049000]
  62. 5702.698494847898754789
  63. 5690.698494847898754789
  64. 34180.190969087392528734
  65. 949.4497491413164591315
  66. 3
  67. 3.14
  68. 03.142
  69. 3
  70. 314.16%
  71. 635,463,773
  72. */

11、 MD5工具类

MD5的全称是Message-Digest Algorithm 5（信息-摘要算法）

  1. //确定计算方法
  2. MessageDigest md5=MessageDigest.getInstance("MD5");
  3. //JDK1.8新增Base64
  4. String newstr = Base64.getEncoder().encodeToString(md5.digest(str.getBytes("utf-8")));
  6. //1.8之前使用sun.misc.BASE64Encoder(此类没有访问权限， 在rt.jar中添加访问权限： sun/misc/*)
  7. BASE64Encoder base64 = new BASE64Encoder();
  8. base64.encode(md5.digest(str.getBytes("utf-8")));
  1. package com.vince;
  3. import java.io.IOException;
  4. import java.io.UnsupportedEncodingException;
  5. import java.security.MessageDigest;
  6. import java.security.NoSuchAlgorithmException;
  7. import java.util.Arrays;
  8. import java.util.Base64;
  10. import sun.misc.BASE64Decoder;
  11. import sun.misc.BASE64Encoder;
  13. public class MD5Demo {
  15.    private static String savePassword = "pmq7VoTEWWLYh1ZPCDRujQ==";//存储的密文
  16.    public static void main(String[] args) {
  18.       test();
  20.       System.out.println(login("admin123456"));
  22.    }
  24.    private static boolean login(String password){
  25.       if(savePassword.equals(md5(password))){
  26.          return true;
  27.       }else{
  28.          return false;
  29.       }
  30.    }
  32.    //计算MD5的工具方法
  33.    private static String md5(String password){
  34.       try {
  35.          MessageDigest md = MessageDigest.getInstance("md5");
  36.          //通过MD5计算摘要
  37.          byte[] bytes = md.digest(password.getBytes("UTF-8"));
  38.          String str = Base64.getEncoder().encodeToString(bytes);
  39.          return str;
  40.       } catch (NoSuchAlgorithmException e) {
  41.          // TODO Auto-generated catch block
  42.          e.printStackTrace();
  43.       } catch (UnsupportedEncodingException e) {
  44.          e.printStackTrace();
  45.       }
  46.       return null;
  47.    }
  49.    private static void test() {
  50.       String password = "admin123456";  //dsfkjdskfj76776f98732 明文（原文）
  51.       String savePassword = "pmq7VoTEWWLYh1ZPCDRujQ==";//存储的密文
  53.       try {
  54.          MessageDigest md = MessageDigest.getInstance("md5");
  55.          //通过MD5计算摘要
  56.          byte[] bytes = md.digest(password.getBytes("UTF-8"));
  57.          System.out.println(Arrays.toString(bytes));
  58.          String mdStr = new String(bytes);
  59.          //System.out.println(mdStr);
  60.          //a-z A-Z 0-9 / * BASE64编码算法
  61. //       1.8版本
  62.          String str = Base64.getEncoder().encodeToString(bytes);
  63.          System.out.println(str);
  65.          //JDK1.8之前使用
  66. //       BASE64Encoder base64 = new BASE64Encoder();
  67. //       String str = base64.encode(bytes);
  68.          //base64解码
  69.          BASE64Decoder decoder = new BASE64Decoder();
  70.          byte[] bs = decoder.decodeBuffer(str);
  71.          System.out.println(Arrays.toString(bs));
  72.       } catch (NoSuchAlgorithmException e) {
  73.          e.printStackTrace();
  74.       } catch (UnsupportedEncodingException e) {
  75.          e.printStackTrace();
  76.       } catch (IOException e) {
  77.          // TODO Auto-generated catch block
  78.          e.printStackTrace();
  79.       }
  80.    }
  82. }
  84. /*
  85. [-90, 106, -69, 86, -124, -60, 89, 98, -40, -121, 86, 79, 8, 52, 110, -115]
  86. pmq7VoTEWWLYh1ZPCDRujQ==
  87. [-90, 106, -69, 86, -124, -60, 89, 98, -40, -121, 86, 79, 8, 52, 110, -115]
  88. true
  89. */

12、Lambda表达式

（1）Lambda表达式

Lambda表达式（也称为闭包） 是整个Java 8发行版中最受期待的在Java语言层面上的改变， Lambda允许把函数作为一个方法的参数（函数作为参数传递进方法中），或者把代码看成数据。

Lambda表达式用于简化JAVA中接口式的匿名内部类。 被称为函数式接口的概念。 函数式接口就是一个具有一个方法的普通接口。 像这样的接口， 可以被隐式转换为lambda表达式。

语法：

(参数1,参数2…) -> { … }

  1. 没有参数时使用Lambda表达式
  2. 带参数时使用Lambda表达式
  3. 代码块中只一句代码时使用Lambda表达式
  4. 代码块中有多句代码时使用Lambda表达式
  5. 有返回值的代码块
  6. 参数中使用final关键字

（2）接口中的默认方法和静态方法

  1. interface A{
  2.     public default void print(){}
  3.     public static void method(){}
  4. }

默认方法与静态方法并不影响函数式接口的契约， 可以任意使用

  1. package com.vince;
  3. import java.util.Arrays;
  4. import java.util.Comparator;
  6. public class LambdaDemo {
  7.    public static void main(String[] args) {
  9. //    IEat ieat = new IEatImpl();
  10. //    ieat.eat();
  12. //    IEat ieat2 = new IEat(){
  13. //       public void eat(){
  14. //          System.out.println("eat banana");
  15. //       }
  16. //    };
  17. //    ieat2.eat();
  20.       //lambda表达式:
  21.       //好处：1代码更简洁，2,不会单独生成class文件
  22. //    IEat ieat3 = ()->{System.out.println("eat apple banana");};
  24.       //没有参数时使用
  25. //    IEat ieat3 = ()-> System.out.println("eat apple banana");
  26. //    ieat3.eat();
  28.       //带参数时使用,参数的类型可以省略
  29. //    IEat ieat3 = (thing,name) -> System.out.println("eat..."+thing+"..."+name);
  30. //    ieat3.eat("apple","大冰");
  32.       //带参数时使用,参数的类型可以省略,代码块中有多行代码
  33. //    IEat ieat3 = (thing,name) -> {
  34. //       System.out.println("eat..."+thing);
  35. //       System.out.println(name);
  36. //    };
  37. //    ieat3.eat("apple","大冰");
  39.       //带返回值的方法
  40. //    IEat ieat3 = (thing,name)->{
  41. //       System.out.println(name+ " eat "+thing);
  42. //       return 10;
  43. //    };
  45.       //带返回值 的方法中只有一句实现代码
  46.       IEat ieat3 = (final String thing,final String name)-> thing==null?1:0;
  47.       ieat3.eat("apple", "大冰");
  49.       Student[] students = {
  50.             new Student("张三",18),
  51.             new Student("张四",28),
  52.             new Student("张一",15)};
  54. //    Arrays.sort(students,new Comparator<Student>() {
  55. //       public int compare(Student o1, Student o2) {
  56. //          return o1.getAge()-o2.getAge();
  57. //       };
  58. //    });
  60. //    Comparator<Student> c = (o1,o2)->o1.getAge()-o2.getAge();
  61.       Arrays.sort(students,(o1,o2)-> o1.getAge()-o2.getAge());
  62.       System.out.println(Arrays.toString(students));
  64.       IEat.method();
  65.    }
  66. }
  69. //只有一个抽象方法的接口
  70. interface IEat{
  71.    public int eat(final String thing,final String name);
  72.    public default void print(){
  73.       System.out.println("print test");
  74.    }
  75.    public static void method(){
  76.       System.out.println("static method..");
  77.    }
  78. }
  80. //class IEatImpl implements IEat{
  81. // public void eat(String thing){
  82. //    System.out.println("eat--"+thing);
  83. // }
  84. //}
  1. package com.vince;
  3. public class Student {
  5.    private String name;
  6.    private int age;
  7.    public String getName() {
  8.       return name;
  9.    }
  10.    public void setName(String name) {
  11.       this.name = name;
  12.    }
  13.    public int getAge() {
  14.       return age;
  15.    }
  16.    public void setAge(int age) {
  17.       this.age = age;
  18.    }
  19.    @Override
  20.    public String toString() {
  21.       return "Student [name=" + name + ", age=" + age + "]";
  22.    }
  23.    public Student(String name, int age) {
  24.       super();
  25.       this.name = name;
  26.       this.age = age;
  27.    }
  28.    public Student() {
  29.       super();
  30.       // TODO Auto-generated constructor stub
  31.    }
  33. }