java常用实用类

已于 2022-12-02 01:17:11 修改
阅读量907 收藏 2
点赞数
分类专栏： java 文章标签： java jvm 数据结构
于 2022-10-31 00:15:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_51976923/article/details/127607720
版权

7. 常用实用类

7.1 String类

在程序设计中经常涉及与字符序列处理有关的算法，为此java提供了String类来处理。

String类在java.lang包中，默认引入，直接可以使用。

String时final类，不能继承扩展。

  • 常量对象

    String常量也是对象，用""括起来的字符序列。

    如：“Hello world”，"你好吖~"等。

    • 常量池：常量存在常量池中。

    • String常量是对象，也有自己的引用和实体。上面常量池左边即引用，右边是实体。

  • String对象

    使用new运算符创建的String类的对象。

    • String类有两个常用的构造方法：

      • String(char a[])
      char[] a = {'y','o','u'};
String s1 = new String(a); //等价于：String s1 = new String("you");
System.out.println(s1); // => you
      • String(Char a[],int startIndex,int count)
      char[] a = {'y','o','u','a','r','e'};
String s2 = new String(a,1,2); // a数组从索引为1的字符开始往后截取两个字符：ou
System.out.println(s2); // => ou

  • 字符串并置

    两个字符串对象用“+”进行并置运算，其实就是首尾连接组成一个新的字符串对象。

    如：“你”+“好”=>“你好”。

    规则：

    • 参与并置的字符串对象，只要有一个是变量，java就会在动态区存放得到的新字符串对象的实体和引用。
    • 参与并置的字符串对象，两个都是常量，那么得到的仍然是常量，如果常量池中没有这个常量，就把这个常量放入常量池。

    案例：

    public class Example8_1 {
    public static void main(String[] args) {
        String s1 = "你好";
        String s2 = "你"+"好";
        System.out.println(s1==s2); //=>true
        System.out.println("你好"==s1); //=>true
        System.out.println("你好"==s2); //=>true

        String t1 = "你";
        String t2 = "好";
        String t3 = t1+t2;
        System.out.println(t3==s1); //=>false
        String t4 = t1+t2;
        System.out.println(t4==t3); //=>false
    }
}

  • String类的常用方法

    • public int length()

      调用length()，获取自身字符序列的长度

      案例：

      String s1 = "good night";
System.out.println(s1.length()); //=>10

    • public boolean equals(String s)

      调用equals，比较自身是否与参数String对象s字符串相同。

      案例：

      String ss = "good night";
String sd = "good night";
String sc = "hello";
System.out.println(ss.equals(sd)); //=>true
System.out.println(ss.equals(sc)); //=>false

    • public boolean startsWith(String s)、public boolean endsWith(String s)

      调用 startsWith(String s)，判断当前String对象是否以参数s开头

      调用 endsWith(String s)，判断当前String对象是否以参数s结尾

      案例：

      String ss = "good night";
String sc = "hello";
System.out.println(ss.startsWith("go")); // => true
System.out.println(sc.startsWith("go")); // => false
System.out.println(ss.endsWith("o"));  // =>false
System.out.println(sc.endsWith("o"));  // =>false

    • public int compareTo(String s)

      调用compareTo(String s)，自身按照顺序去和参数s一一比较大小，如果全部相等则返回0，小于返回负值，大于返回正值。

      比较方法是按照字符序列顺序一一比较对应位置的字符的unicode值。

      案例：

      String sc = "hello";
System.out.println(sc.compareTo("hello"));// =>0
System.out.println(sc.compareTo("hell")); // => 正数
System.out.println(sc.compareTo("hellp"));// => 负数

    • public boolean contains(String s)

      调用contains(String s)，判断自身是否包含传入的参数s对象

      案例：

      String sc = "hello";
System.out.println(sc.contains("hed"));// =>false
System.out.println(sc.contains("he")); // =>true

    • public int indexOf(String s) 、public int lastIndexOf(String s)

      调用indexOf(String s)，从0索引位置开始检索首次出现 s 的位置，并返回该位置，找不到返回-1。

      调用lastIndexOf(String s)，从0索引位置开始检索最后一次出现 s 的位置，并返回该位置，找不到返回-1。

      案例：

      String test = "I am a good cat";
System.out.println(test.indexOf("g")); // => 7
System.out.println(test.indexOf("good")); // => 7
System.out.println(test.indexOf("gd")); // => -1
System.out.println(test.lastIndexOf("o")); // =>9

      注意：indexOf(String s,int startpoint) 是一个重载方法，可以指定开始检索的位置。

    • public String substring(int startpoint)

      调用substring(int startpoint)，截取复制从startpoint索引位置开始到最后位置上的字符序列并返回。

      调用重载方法substring(int start,int end),截取复制从start索引位置至end-1索引位置上的字符序列并返回。

      案例：

      String test = "I am a good cat";
System.out.println(test.substring(2)); // => am a good cat
System.out.println(test.substring(3,8));// => m a g

    • public String trim()

      调用trim(),可以得到去掉前后空格的字符序列并返回

      案例：

      String trim = "  嗨嗨嗨  ";
System.out.println(trim.trim()); // => 嗨嗨嗨

  • 字符串与基本数据的相互转化：

    • 基本数据转字符串：

      String.valueOf(基本数据)
// 如
String.valueOf(123) // => "123"

    • 数字组成的字符串转基本数据：

      Integer.parseInt("123") // => 123
Float.parseFloat("123") // => 123.0f
···

  • 字符串与字符数组

    • public void getChars(int start,int end,char c[],int offset)

      调用getChars(int start,int end,char c[],int offset)，使当前String对象复制从start位置到end-1位置的字符序列到字符数组c的offset位置。

      String str2 = "hello";
char[] a;
a = new char[10];
str2.getChars(0,2,a,4);
System.out.println(a);

    • public char[] toCharArray()

      调用toCharArray()方法，返回一个字符数组。

      String str2 = "hello";
char[] a;
a = new char[10];
str2.getChars(0,2,a,4);
a=str2.toCharArray();
System.out.println(a);

  • 正则表达式：

    正则表达式是一个String对象的字符序列，该字符序列中含有具有特殊意义的字符，这些字符称为正则表达式的元字符。

    • 常用元字符：

      元字符写法意义
      ..代表任何一个字符
      \d\\d代表0-9中的任何一个数字
      \D\\D代表任何一个非数字字符
      \s\\s代表空格类字符，‘’\t’,‘\n’,‘\x0B’,‘\f’,‘\r’
      \S\\S代表非空格类字符
      \w\\w代表可用于标识符的字符（不包括美元字符）
      \W\\W代表不能用于标识符的字符
      \p{Lower}\\p{Lower}小写字母[a-z]
      \p{Upper}\\p{Upper}大写字母[A-Z]
      \p{ASXII}\\p{ASXII}ASCII字符
      \p{Alpha}\\p{Alpha}字母
      \p{Digit}\\p{Digit}数字字符[0-9]
      \p{Alnum}\\p{Alnum}字母或数字
      \p{Punct}\\p{Punct}标点符号：!"#$%'()*+,-./:;<=>?@[]^_`{|}~
      \p{Graph}\\p{Graph}可视字符:\p{Alnum}\p{Punct}
      \p{Print}\\p{Print}可打印字符:\p{Print}
      \p{Blank}\\p{Blank}空格或制表符[\t]
      \p{Central}\\p{Central}控制字符：[\x00-\x1F\x7F]

      例如：“\dcat” ==>“0cat”、“1cat”、···"9cat"都是与之匹配的字符序列。

      public boolean matches(String regex)：

      调用此方法，可以判断当前String对象字符序列是否和参数regex指定的正则表达式匹配。

      案例:

      String str3 = "0abc";
System.out.println(str3.matches("\\dabc")); //==>true

    • 方括号[]元字符

      正则表达式中可以用方括号括起来若干个字符表示一个元字符，该元字符代表方括号中任何一个字符。

      • [abc]:代表a、b、c中的任何一个

      • [a-zA-Z]:代表英文字母中的任何一个

      • [a-d]:代表a-d中任何一个

      • [a-d[m-p]]:代表a-d,或m-p中任何一个字符 (并)

      • [a-z$$[def]]:代表d、e或f中任何一个（交）

      • [a-f&&[^bc]]:代表a、d、e、f中任何一个 (差)

      案例：“[012]abc” ==>“0abc”、“1abc”、"2abc"是与其匹配的字符序列

      String str3 = "0abc";
System.out.println(str3.matches("[012]abc")); // =>true

    • 限定符

      限定符可以起到限制的作用。

      常用限定符：

      限定符意义
      X？X出现0次或1次
      X*X出现0次或多次
      X+X出现1次或多次
      X{n}X恰好出现n次
      X{n,}X至少出现n次
      X{n,m}X出现n-m次
      XYX的后缀是Y
      X|YX或Y

      案例：“3bc” ==> "3b?c"是与其匹配的字符序列之一

      String str3 = "3bc";
System.out.println(str3.matches("3b?c")); // =>true
System.out.println(str3.matches("3b{5}c")); // =>false

    案例：判断输入的字符串是否由数字、字母、下划线构成。

    import java.util.Scaner
String regex = "[a-zA-Z|0-9|_]+";
Scanner sc1 = new Scanner(System.in);
String str4=sc1.nextLine();
if(str4.matches(regex)){
            System.out.println(str4+"是由数字字母下划线组成");
        }
else{
            System.out.println(str4+"不是由数字字母下划线组成");
        }

  • 字符串的替换

    编程过程中，我们经常使用到字符串之间的替换。

    • public String replaceAll(String regex, String replacement)

      调用此方法，返回一个新String对象，这个对象的字符序列是由当前String对象的字符序列中所有和参数regex匹配的子字符序列，用参数replacement的字符序列替换后得到的字符序列

      案例：

      String str5 = "123abc".replaceAll("[0-9]","r");
System.out.println("str5);//=>rrrabc

  • 字符串的分解

    编程过程中，我们也经常要去对字符串进行分割。

    • public String[] split(String regex)

      调用此方法，当前String对象的字符序列由指定的正则表达式regex作为分隔符分割，并返回一个以分割后的所有子字符串作为元素的字符串数组。

      案例：

      String str6="123abc";
String[] strArr;
strArr = new String[2];
strArr =  str6.split("3");
for(String s:strArr){
          System.out.print(s+" "); //=>12 abc 
        }

      注意：split方法认为分割符左侧应该是单词，所以如果regex参数和当前String对象字符序列前缀相同，返回的字符串数组第一个元素应该是空字符串"“，比如上面:String s[]=str6.split(“1”),那么s[0]=>”",s[1]=>“23abc”

7.2 StringTokenizer类

上面我们学习了调用split()方法实现字符串的分解，当我们想对字符串进行分词的时候，虽然可以调用split()实现，但是我们还可以使用java的StringTokenizer类来实现。

  • StringTokenizer类两个构造方法：

    • StringTokenizer(String s)

      传入一个String对象，然后用默认的分割符：空格符、换行符、回车符、Tab符、进纸符进行分割。

      例如：

      String s = "you are welcome";
StringTokenizer st = new StringTokenizer(s);
while(st.hasMoreTokens()){
            System.out.print(st.nextToken()+" "); // ==>you are welcome
        }

    • StringTokenizer(String s,String delim)

      传入一个String对象s，然后以参数delim字符序列中的字符的任意排列作为分割标记。

      例如：

      String s = "you#are|##welcome";
StringTokenizer st = new StringTokenizer(s,"|#");
while(st.hasMoreTokens()){
            System.out.println(st.nextToken()); // ==>you are welcome
        }

  • StringTokenizer类三个常用方法

    • public boolean hasMoreTokens()

      调用此方法，判断是否还有单词，有就返回true，否则返回false，常用于while循环逐个获取单词时

      例子：

      String s = "you are welcome";
StringTokenizer st = new StringTokenizer(s);
while(st.hasMoreTokens()){ // 调用hasMoreTokens()
            System.out.print(st.nextToken()+" "); // ==>you are welcome
        }

    • public int countTokens()

      调用此方法，返回单词的数量。

      例子：

      String s = "you are welcome";
StringTokenizer st = new StringTokenizer(s);
System.out.print(st.countTokens()); // =>3

    • public String nextToken()

      调用此方法，逐个获取分割单词。

      例子：

      String s = "you are welcome";
StringTokenizer st = new StringTokenizer(s);
while(st.hasMoreTokens()){
            System.out.print(st.nextToken()+" "); // ==>调用nextToken方法逐个获取分割的单词
        }
7.3 Scanner类

上面使用了StringTokenizer类来分割解析字符串单词，其实用Scanner类也可以。

  • 构造一个Scanner类对象

    String nba = "I love game";
Scanner sc = new Scanner(nba); // 因为要分割解析nba字符串， 传入nba字符串

  • 调用useDelimiter(String regex)

    sc.useDelimiter() //不传参数，默认:空格、制表符、回车符分割

String regex = " ";
sc.useDelimiter(regex);

  • 调用hasNext()判断是否还有单词，有返回true，否则false

    sc.hasNext()//=>true

  • 调用next()一次获取解析的单词

    sc.next() //=>I
sc.next() //=>love
sc.next() //=>game
  
//如果是数字型单词，可以调用nextInt()或nextDouble()代替next()方法。

案例：

 String mes = "苹果：10元/kg,香蕉：5.5元/kg,桃子：2.33元/kg";
 Scanner sc = new Scanner(mes);
 String regex = "[^0-9.]+";
 sc.useDelimiter(regex);
 while(sc.hasNext()){
            try{
                System.out.println(sc.nextInt());
            }
            catch (Exception e){
                System.out.println(sc.nextDouble());
            }
            
        }
7.4 StringBuffer类

前面学习了String对象，我们知道String对象的字符序列是不能改变的， 有时候我们想改变字符序列，比如在"hello"后面增加"world"字符序列变成"helloworld"，该怎么办呢？

这时候我们可以使用StringBuffer类。

  • StringBuffer类三个构造方法：

    • StringBuffer()

      无参构造方法，分配给对象的实体初始可以容纳16个字符，长度大于16时，实体容量自动增加以便存放增加的字符。
      通过length()可以获取字符序列长度。

      通过capacity()可以获取当前实体的实际容量。

    • StringBuffer(int size)

      指定参数size，分配给对象的实体初始可以容纳size个字符，长度大于size时，实体容量自动增加以便存放增加的字符。

    • StringBuffer(String s)

      指定参数s，分配给对象的实体初始可以容纳s的长度+16个字符，

  • StringBuffer类的常用方法：

    • StringBuffer append(String s)

      将String对象s的字符序列追加到当前StringBUffer对象的字符序列中，并返回当前StringBuffer对象的引用。

      例子:

      StringBuffer sb = new StringBuffer("123");
sb.append("abc");
System.out.println(sb);//=>123abc

      注意：append方法可以传入int，boolean，double，char等数据类型的数据，会自动转化为String对象，然后追加到后面。如上面的sb对象：sb.append(4) =>1234。

    • Public char charArt(int n)和public void setCharAt(int n, char ch)

      调用 charArt(int n)方法，获取当前对象n位置上的字符。

      调用 setCharAt(int n, char ch)方法，用参数ch替换当前对象n位置上的字符。

      例子：

      StringBuffer sb = new StringBuffer("123");
System.out.println(sb.charAt(0)); // =>1
sb.setCharAt(0,'0')
System.out.println(sb.charAt(0)); // =>0

    • StringBuffer insert(int index,String str)

      调用insert(int index,String str)方法，将参数str指定的字符序列插入到参数index指定的位置，并返回当前对象的引用。

      例子：

      StringBuffer sb = new StringBuffer("123");
sb.insert(1,"insert");
System.out.println(sb); // 1insert23

    • public StringBuffer reverse()

      调用reverse()方法，反转字符串，返回当前对象引用。

      例子：

      StringBuffer sb = new StringBuffer("123");
sb.reverse();
System.out.println(sb); //=>321

    • StringBuffer delete(int startIndex,int endIndex)

      调用delete(int startIndex,int endIndex)方法,删除startindex到endIndex-1位置的字符序列，并返回当前对象的引用。

      例子：

      StringBuffer sb = new StringBuffer("123");
sb.delete(0,2);
System.out.println(sb); // =>3

      补充：删除单个字符也可以用deleteCharAt(int index)方法，删除index位置的字符

    • StringBuffer replace(int startIndex,int endIndex,String str)

      调用replace(int startIndex,int endIndex,String str)方法,用str替换当前对象从startIndex到endIndex-1位置的子字符串。

      例子：

      StringBuffer sb = new StringBuffer("123");
sb.replace(0,2,"dd");
System.out.println(sb); // =>dd3
7.5 Date类与Calendar类

程序中经常需要用到日期、时间等数据，为了方便程序员，java提供了Date类和Calendar类。

  • Date类（java.util）

    处理日期和时间

    两个构造函数：

    • Date()

      无参构造函数，获取本机当前日期和时间

      例子：

      Date nowTime = new Date();
System.out.println(nowTime);// Mon Oct 10 21:12:18 CST 2022(程序运行当前时间)

      补充：输出nowTime的时候，没有输出nowTime对象的引用，是因为Date类重写了object类的toString方法，使得System.out.println(nowTime);输出的实体中的时间。

    • Date(long time)

      带time参数构造函数。

      计算机系统以格林威治时间（1970年1月1日0时）为起点，根据这个时候传入time参数，创建一个往后移动time毫秒的Date对象。

      例子：

      Date Time = new Date(1000);
System.out.println(Time); // => Thu Jan 01 08:00:01 CST 1970(按照格林威治时间时：1970 1.1 00:00:01，但是北京和格林威治时间相差8小时，所以是1970 1.1 08:00:01)

      补充：获取本地时间戳：用System类的静态方法public long currentTimeMillis()获取当前系统时间戳(时间戳就是从格林威治时间到目前时刻走过的毫秒数)

       System.out.println(System.currentTimeMillis());
// =>1665408378190（当前时间戳）

  • Calendar类（java.util）

    处理日历

    • 使用getInstance()初始化日历对象

      Calendar calendar = Calendar.getInstance();

    • 调用set方法可以设置日期：

      public final void set(int year,int month,int date);
public final void set(int year,int month,int date,int hour,int minute);
public final void set(int year,int month,int date,int hour,int minute,int second);
// year取负数表示实际世界公元前

    • 调用get方法获取年月份小时等信息。

      public int get(int field) //field由Calender的静态常量指定

    案例：

    Calendar calendar = Calendar.getInstance();
calendar.setTime(new Date());
int year = calendar.get(Calendar.YEAR),
    month = calendar.get(Calendar.MONTH),
    day = calendar.get(Calendar.DAY_OF_MONTH),
    hour = calendar.get(Calendar.HOUR),
    minute = calendar.get(Calendar.MINUTE),
    second = calendar.get(Calendar.SECOND);
System.out.println(year+"年"+month+"月"+day+"日"+" "+hour+":"+minute+":"+second);
// => 2022年9月10日 9:57:4
7.6 日期格式化

上面学习了如何获取日期和时间，但是可能得到的格式不是我们想要的格式，这时候就可以给日期格式化成我们想要的格式。

使用String类的format方法进行格式化。

  • format方法

    format(格式化模式，日期列表)

    格式化模式：普通字符和时间格式符组成的字符串。

    日期列表：用逗号隔开的Calendar对象或Date对象。（格式化模式中格式符个数要和日期列表中日期个数相同）

    • 时间格式符

      格式符作用
      %tY年(4位数)
      %ty年(2位数)
      %tm月(2位数)
      %tp日（区分上午下午）
      %td日(月中的天)
      %tj日(年中的天)
      %tB月(月份全称)
      %tb月(月份简称)
      %tA日（当日星期几，全称）
      %ta日（当日星期几，简称）
      %tH时（2位数，24小时制）
      %tl时（2位数，12小时制）
      %tM分（2位数）
      %tS秒（2位数）
      %tL毫秒（3位数）
      %tN微秒（9位数）
      %tz日期与GMT偏移量（4位数）
      %tZ时区名称缩写
      %tR等价于 %tH:%tM
      %tT等价于 %tH:%tM:%tS
      %tr等价于 %tH:%tM:%tS%Tp
      %tD等价于 %tm/%td/%ty
      %tF等价于 %tY-%tm-%td
      %tc等价于 %ta $tb %td %tT %tZ %tY)（例如星期二 二月 10 17:50:07 CST 2011）

    案例：

    Date Time = new Date();
Calendar calendar = Calendar.getInstance();
calendar.setTime(new Date());
System.out.println(String.format("%tF",calendar)); //=>2022-10-10
System.out.println(String.format("%tY:%tm:%td %tH:%tM:%tS",Time,Time,Time,Time,Time,Time));
//=>2022:10:10 22:15:42
7.7 Math类、BigInteger类与Random类

  • Math类

    编写程序时，经常数学计算。

    比如计算一个数的平方根、绝对值，获取随机数等。

    Java.lang包中的Math类，包含很多static方法，可以直接通过Math类名调用。

    • 两个static常量

      • E ：2.7182828284590452354
      • PI ：3.14159265358979323846

    • 常用方法：

      • public static long abs（double a)

        调用abs（double a)方法，返回a的绝对值

        例子：

        System.out.println(Math.abs(-3.4)); //=>3.4

      • public static double max（double a,double b)

        调用max（double a,double b)方法，返回a、b的最大值

        例子：

        System.out.println(Math.max(3,4));//=>4

      • public static double min(double a,double b)

        调用min(double a,double b)方法，返回a、b的最小值

        例子：

        System.out.println(Math.min(3,4)); //=>3

      • public static double random()

        调用random()方法，产生一个0～1之间的随机数（不包括0和1）

        例子：

        System.out.println(Math.random()); //=>0.9065800983054965

      • public static double pow(double a,double b)

        调用pow(double a,double b)方法，返回a的b次幂

        例子：

        System.out.println(Math.pow(2, 3)); //=>8.0

      • public static double sqrt(double a)

        调用sqrt(double a)方法，返回a的平方根

        例子：

        System.out.println(Math.sqrt(4));//=>2.0

      • public static double log(double a)

        调用log(double a)方法，返回a的对数

        例子：

        System.out.println(Math.log(9));//=>2.1972245773362196

      • public static double sin(double a)

        调用sin(double a)方法，返回a的正弦值

        例子：

        double degrees = 45.0;
double radians = Math.toRadians(degrees);
System.out.format("%.1f 度的正弦值为 %.4f%n", degrees, Math.sin(radians));
//=>45.0 度的正弦值为 0.7071

      • public static double asin(double a)

        调用asin(double a)方法，返回a 的反正弦值

        例子：

        double degrees = 45.0;
double radians = Math.toRadians(degrees);
System.out.format("%.1f 度的反正弦值为 %.4f%n", degrees, Math.asin(radians));
//=>45.0 度的反正弦值为 0.9033

      • public static double ceil(double a)

        调用ceil(double a)方法，返回大与a的最小double型整数

        例子：

        System.out.println(Math.ceil(2.3));//=>3.0

      • public static double floor(double a)

        调用floor(double a)方法，返回小于a的最小double型整数

        例子：

        System.out.println(Math.ceil(2.3));//=>2.0

      • public static long round(double a)

        调用round(double a)方法，返回a四舍五入后的值。（大于5入，小于等于5舍）

        例子：

        System.out.println(Math.round(3.51)); //=>4
System.out.println(Math.round(3.50)); //=>3

  • BigInteger类

    程序如果要处理特别大的整数，就需要用到BigInteger类。

    • 构造函数：public BigIngeger(String val)

      BigInteger类创建对象，传入数字型字符串val构造一个BigInteger对象。

      不是数字型字符串就会抛出NumberFormatException异常

      例子：

      BigInteger bi = new BigInteger("213142421421");
System.out.println(bi);

    • 常用方法：

      • public BigInteger add(BigInteger val)

        返回当前对象与val的和

      • public BigInteger substract(BigInteger val)

        返回当前对象与val的差

      • public BigInteger multiply(BigInteger val)

        返回当前对象与val的积

      • public BigIngeger divide(BigInteger val)

        返回当前对象与val的商

      • public BigInteger remainder(BigInteger val)

        返回当前对象与val的余

      • public int compareTo(BigInteger val)

        返回当前对象与val对象比较的结果，大于返回1，小于返回-1，等于返回0

      • public BigInteger abs()

        返回当前整数对象的绝对值

      • public BigInteger pow(int a)

        返回当前对象的a次幂

      • public String toString()

        返回当前对象十进制的字符串表示

      • public String toString(int p)

        返回当前对象p进制的字符串表示

    案例：

    import java.math.BigInteger;

public class BigIntegerDemo {
    public static void main(String[] args) {

        BigInteger addresult = new BigInteger("0"),
                divresult = new BigInteger("0"),
                subresult = new BigInteger("0");
        BigInteger a= new BigInteger("324324344");
        BigInteger b = new BigInteger("213142421421");
        addresult = a.add(b); // 和
        divresult = a.divide(b); //商
        subresult = a.subtract(b); //差
        System.out.println(addresult); //=>213466745765
        System.out.println(divresult); //=>0
        System.out.println(subresult);//=>-212818097077
    }
}

  • Random类

    随机数我们可以用上面的Math.random()方法生成，但java提供了更灵活的随机数类Random。

    • 两个构造方法：

      public Random(); //以当前系统时间作为随机数种子创建Random对象
public Random(long seed); //以seed参数作为随机数种子创建Random对象

    • 常用方法：

      • nextInt()

        调用nextInt()方法，返回一个随机整数

        例子:

        Random rd = new Random();
System.out.println(rd.nextInt());

      • nextInt(int m)

        调用nextInt(int m)方法，返回0-m(不包括m)的随机整数

        例子：

        Random rd = new Random();
System.out.println(rd.nextInt(100));// 返回[0,99]的一个整数

      • nextDouble()

        调用nextDouble()方法，返回0.0～1.0之间的随机数，包括0.0,不包括1.0

        例子：

        Random rd = new Random();
System.out.println(rd.nextDouble());

      • nextBoolean()

        调用nextBoolean()方法，随机返回true和false

        例子:

        Random rd = new Random();
System.out.println(rd.nextBoolean());
7.8 数字格式化

我们经常需要对数字进行格式化。

比如：3.1415926保留两位小数成3.14，1234567按千分组成"1,234,567"

方法：调用String类的format方法进行数字格式化。

  • format(格式化模式，值列表)

    • 格式化模式

      格式符+普通字符组成的字符序列。

    • 值列表

      用逗号分隔的变量、常量或表达式（值列表个数要和格式化模式中的格式符个数相同）

    • 格式化顺序

      格式化模式中的格式符和值列表从左到右一一对应

    例子：

    int x =888;
float y = 3.141592f;
String s = String.format("从左到右:%d,%.3f,%d",x,y,100);
System.out.println(s); // =>从左到右:888,3.142,100

    注意：如果格式化模式中包含普通%,需要连续输入%%表示要输出%,比如要输出75%。

    System.out.println(String.format("%d%%",75));

  • 格式化整数

    格式符意义
    %d将值格式转换为十进制整数
    %o将值格式转化为八进制整数
    %x将值格式转化为小写十六进制整数，例：abc58
    %X将值格式转化为大写十六进制整数，例：ABC58

    修饰符：%+d （强制加上+号）%,d(按千分组)

    数据宽度：

    format方法返回的字符串的长度。

    格式：%md (返回m长度的字符串，在数字前面加空格) %-md (在数字后面加空格)

    • 案例:

      				int x =8888;
        int y = 9123456;
        System.out.println(String.format("十进制x:%d",x));//十进制x:8888
        System.out.println(String.format("八进制x:%o",x));//八进制x:21270
        System.out.println(String.format("小写十六进制x:%x",x));//小写十六进制x:22b8
        System.out.println(String.format("大写十六进制x:%X",x));//大写十六进制x:22B8
        System.out.println(String.format("加+修饰符:%+d",x));//加+修饰符:+8888
        System.out.println(String.format("按千分组:%,d",y));//按千分组:9,123,456
        System.out.println(String.format("数据宽度8：%8d",x));//数据宽度8：    8888

  • 格式化浮点数

    格式符意义
    %f将值格式转换为十进制浮点数,小数点保留6位（float）
    %e（%E)将值格式转化为科学记数法的十进制浮点数(Float)

    修饰符：%+f （强制加上+号）%,f(整数部分按千分组)

    小数位数和数据宽度：

    小数位数

    指定保留几位小数.

    格式：%.nf(保留n位小数)，例：%.3f（保留3位小数）

    数据宽度：

    format方法返回的字符串的长度。

    格式：%mf (返回m长度的字符串，在数字前面加空格) %-mf (在数字后面加空格)

    • 案例:

      float x =1123.14159f;
System.out.println(String.format("float:x:%f",x));// float:x:1123.141602
System.out.println(String.format("加+修饰符:%+f",x));//加+修饰符:+1123.141602
System.out.println(String.format("整数部分按千分组:%,f",x));//整数部分按千分组:1,123.141602
System.out.println(String.format("保留3位小数：%.3f",x));//保留3位小数：1123.142
System.out.println(String.format("数据宽度16：%16f",x));//数据宽度16：     1123.141602
7.9 Pattern类与Match类

有时候，我们需要从字符串中提取一些我们需要的数据，比如从账单中，提取所有单笔花销然后计算出总花销。这时候我们就需要用到java中的模式匹配。

模式匹配：检索和指定模式匹配的字符串。

java提供两个类：Pattern类和Matcher类（java.util.regex包中）

模式匹配流程：

需求：计算账单:"市话：76.8元，长途：167.38元，短信：12.68元"的总价格。

    1. 建立Pattern对象
    String input = "市话：76.8元，长途：167.38元，短信：12.68元";
String regex = "[0-9.]+"; // 正则表达式
Pattern pattern = Pattern.compile(regex); //使用正则表达式regex做compile的参数返回一个Pattern对象。
    1. 建立Matcher对象
    Matcher matcher = pattern.matcher(input);//把字符串input作为参数传给pattern对象的matcher方法，返回一个Matcher对象的引用
    1. 通过Matcher对象去检索匹配

    Matcher类常用方法：

    • public boolean find()

      调用find()方法，查找input字符串中是否有和正则表达式regex匹配的子字符串，有返回true，没有返回false

      如果find()返回true，下次在调用find()方法，就会从上次匹配到的子字符串位置开始往后匹配。

      如果find()返回true，那么就可以调用start()方法和end()方法得到匹配到的子字符串开始位置和结束位置。

      如果find()返回true，那么就可以调用group()方法得到匹配到的子字符串。

    • public boolean matches()

      调用matches()方法，判断输入的字符串input是否和正则表达式regex完全匹配。

    • public String replaceAll(String replacement)

      调用replaceAll(String replacement)方法，返回一个字符串，这个字符串是把input字符串中所有和正则表达式regex匹配的子字符串全部替换为replacement字符串后的字符串。

    • public String replaceFirst(String replacement)

      和上面replaceAll差不多，不过这个只是替换第一个匹配到的子字符串。

     Double sum = 0.0;
 while(true){
            if (matcher.find()){
                Double price =Double.parseDouble(matcher.group());
                sum += price;
            }
            else{
                System.out.println("总价："+sum); // 总价：256.86
                break;
            }
        }

    完整代码：

    import java.util.regex.*;
public class PatternDemo {
    public static void main(String[] args) {

        String input = "市话：76.8元，长途：167.38元，短信：12.68元";
        String regex = "[0-9.]+"; // 正则表达式
        Pattern pattern = Pattern.compile(regex); //使用正则表达式regex做compile的参数返回一个Pattern对象。
        Matcher matcher = pattern.matcher(input);//把字符串input作为参数传给pattern对象的matcher方法，返回一个Matcher对象的引用
        Double sum = 0.0;
        while(true){
            if (matcher.find()){
                Double price =Double.parseDouble(matcher.group());
                sum += price;
            }
            else{
                System.out.println("总价："+sum);
                break;
            }
        }
    }
}
【Object类、常用API】
09-09 1122
day01【Object类、常用API】 主要内容 Object类 Date类 DateFormat类 Calendar类 System类 StringBuilder类 包装类 教学目标 -[ ] 能够说出Object类的特点-[ ] 能够重写Object类的toString...
java实用类
ld525327的博客
08-11 231
枚举定义： 枚举：指由一组固定的常量组成的类型枚举的优势 枚举可以使代码易于维护，保证类型安全 枚举易于输入，使用枚举赋值，只需要输入枚举名，然后输入点操作符就能将所有的值显示出来。 枚举使代码更清晰，允许使用描述性的名称表示数据，使用时直观方便。 Java语言是面向对象的，但是Java中的基本数据类型却不是面向对象的，这在实际开发中存在很多的不便。为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类，称为包装类。包装类的作用
Java中的实用类
qq_48802281的博客
08-16 509
Java中的实用类
java实用_java常用实用类
weixin_29016833的博客
02-20 128
1、String类概念java程序中默认导入java.lang包的，像java.lang.String等String类属于final类，用户不能扩展String类，String 类没有子类。String类常见的方法有如下：public int length(); public boolean equals(); public boolean startsWith(); pu...
Java常用实用类
weixin_59806308的博客
03-17 2162
Java常用实用类
JAVA常用类总结
12-22
JAVA常用类,java封装类,String类和StringBuffer类......
实验5 JAVA常用类.doc
05-02
- **String** 类在Java中是不可变的，这意味着一旦创建了String对象，就不能改变它的值。常用的方法包括 `concat()`、`substring()`、`indexOf()`、`replace()` 等。 - **StringBuffer/StringBuilder** 是可变的...
Java-常用实用类.pptx
最新发布
04-21
常用实用类，比如Double和Float，为Java程序员提供了极大的便利，使得基本数据类型的操作更加灵活。掌握这些类的使用方法对于进行高效的Java编程至关重要。通过这些类，我们可以在需要时将基本类型与对象类型之间...
java常用实用类实验结论
07-03
Java中有很多内置的实用类（Util Classes）和工具包（如java.util、java.io等），它们提供了丰富的功能，方便开发者进行日常的编程操作。进行这些类的实验后，通常会得出以下几个结论： 1. **易用性**：Java的实用...
Java开发过程中常用的实用类
04-19
### Java开发过程中常用的实用类 在Java开发过程中，利用一些内置的实用类可以极大地提高开发效率，简化代码逻辑。本文将详细介绍几个常见的实用类及其应用方法。 #### 一、Math类 `Math` 类提供了丰富的数学运算...
Java高级特性：实用类
qi341500的博客
08-09 455
一、枚举类型 枚举类型优点： 二、包装类 1、包装类有何作用 2、包装类和基本数据类型的对应关系 3、包装类的构造方法 4、包装类的常用方法 三、装箱和拆箱 包装类的特点 Math类 Random类 四、String类 “==”和equals()有什么区别呢？ 字符串的搜索和提取方法 五、StringBuffer类： 六、String类、StringBuffer类和StringBuilder类的区别？ 七、获取时间：Date类、Calendar类 Calendar类...
Java实用类
一个成长中的程序员，期待用技术的眼光生活
10-24 303
一、枚举 1、定义 枚举是指由一组固定常量组成的类型，关键字enum 2、示例 public enum Gender{ Men,Female } 二、包装类 1、常用包装类 Byte、Boolean、Short、Double、Integer、Character、Long、Float 2、包装类都是final类型，不能创建子类 3、基本数据类型转换为包装类： ①构造方法 Integer itr =...
Java常用实用类的总结
xiaohui的博客
07-15 882
1.String类 　　（1）对字符串的操作，正则表达式，字符串的替换和分解 2.StringToKenizer类 　　（1）对字符串的分解以及数量统计 3.Scanner类 　　（1）解析字符串 4.Date与Calendar类 　　（1）时间日期操作 5.日期的格式化 　　（1）使用SimpleDateFormat对日期格式化 6.Math、BigInteger、Random 　　（1）Math数学计算 　　（2）BigInteger用于处理大整数 　　（3）Random生产随
Java程序设计——常用实用类
Mr_John
11-28 1967
一、String类 1.String类的初始化 ①使用字符串常量直接初始化一个String对象 String str = "abc"; ②使用String的构造方法初始化字符串对象 // 创建一个空的字符串 String str1 = new String(); // 创建一个内容为abcd的字符串 String str2 = new String("abcd"); // 创建一个内容为字符数组的字符串 char []charArray = n
Java常用实用类汇总
弑神灬索隆。
08-16 715
一、8.1.3 String类的常用方法 （1） Boolean型 contain（String s）：判断当前String字符是否包含参数s的字符序列。 （2） Int型IndexOf（String s）和Iast IndexOf（String s）（从后开始）： 例：String tom – “I am a good cat” Tom. IndexOf（“a”） //值是2 Tom. IndexOf（“good”，2） //值是7 （3） String型 substring（int sta
Java——常用实用类
Flora_SM的博客
12-20 729
1.  String 类 1.1  连接字符串 连接字符串可以通过运算符“+”实现，意思是将多个字符串合并到一起生成一个新的字符串。 对于“+”运算符，如果有一个操作元为String类型，则为字符串连接运算符。字符串可与任意类型的数据进行字符串连接的操作，若该数据为基本类型则会自动转换为字符串，若为引用类型，则会自动调用所引用对象的toString()方法获得一个字符串，然后进行字符串连接的...
Java实用类汇总
Treasure_zhou的博客
03-07 945
Java类汇总
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值