Java常用类

这次我归类一些我们平时比较常用的类。

 

注意：java.lang包是系统默认引入的

java.lang包中的常用类
   1.和基本类型对应的8中类类型
      byte      -> Byte
      short     -> Short
      int         -> Integer
      long      -> Long
      float       -> Float
      double   -> Double
      char      -> Character
      boolean  -> Boolean

      例:Integer,封装了基本的int类型的类

          属性:
                 int的最大值：Integer.MAX_VALUE  

Integer a = Integer.MAX_VALUE;

 结果是:2147483647
                 int的最小值：Integer.MIN_VALUE

Integer b = Integer.MIN_VALUE;

 结果是:-2147483648
         方法:
                将整数转成字符串：

    默认的转换成10进制

String ss = Integer.toString(99);

   
                将整数转成对应进制的字符串：

    以下是控制转换成2进制的数   

String sz = Integer.toString(99, 2);

                 将纯数字字符串转成整数：

    默认的转换成10进制

Integer a = Integer.valueOf("123");

    以下是控制转换成4进制的数                                                  

Integer b = Integer.valueOf("123",4);

  
               将纯数字字符串转成整数：

    默认的转换成10进制

Integer a = Integer.parseInt("123");

    以下是控制转换成4进制的数                                                 

Integer b = Integer.parseInt("123",4);

 ----------------------------------------------------------------------------------------------
2.Math类
  属性:
          E:对数的底数e
          PI:π

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

 结果:2.718281828459045
         3.141592653589793
  方法:
         求绝对值：

System.out.println(Math.abs(-12));

         最大值：

System.out.println(Math.max(10, 2));

 
         最小值：

System.out.println(Math.max(10, 2));

 
        a^b：

System.out.println(Math.pow(3, 3));

 
         根号a：

System.out.println(Math.sqrt(4));

 
        随机数    double类型，范围是[0,1]：

System.out.println(Math.random());

 以上方法的结果是：

12
10
10
27.0
2.0
0.08046354424772217
------------------------------------------------------------------------------------------
3.System类

   输出流类：
   System.out.println();

   输出错误类：
   System.err.println();

   输入流类：
   System.in
   正常退出程序:

   System.exit(0);
 
   系统当前时间，以1970-01-01 00:00:00:0000开始计算到现在经历过的毫秒数
  

long  t = System.currentTimeMillis();

    结果是：1480999295075

 

   复制数组
   System.arraycopy(a, 1, b, 4, 3);
               参数1：源数组
               参数2：源数组中的起始下标位置
               参数3：目标数组
               参数4：目标数据中的起始下标位置
               参数5：要复制的个数
 

int[] a = { 1, 2, 3, 4, 5 };
		int[] b = new int[6];
		System.arraycopy(a, 2, b, 3, 2);
		for(int i=0;i<b.length;i++){
			System.out.print(b[i]);
		}

 结果是：000340
------------------------------------------------------
4.字符串类
   String类:
               字符集标准：一个字符是由哪些字节构成，有多套不同的标准
               例:ISO-8859 西欧字符集，不包含全角字符
                   GB2312/GBK 简体中文字符集
                   Big5  繁体中文字符集
                   UTF-8  基于Unicode编码的字符集
 
   ANSI表示采用当地默认的字符集标准
 
   构造方法:
                 字节数组转换成字符串
                                                  String(byte[] bytes)
                                                  String(byte[] bytes,"字符集编码")
                                                  String(byte[] bytes,start,length)

                                                             参数1:转换的字符串

                                                             参数2:字符串开始的下标

                                                             参数3:长度

                字符数组转换成字符串
                                                 String(char[] c)
                                                 String(char[] c,start,length)

                                                           参数1:转换的字符串

                                                           参数2:字符串开始的下标

                                                           参数3:长度

  方法:
         字符串转换成字节数组

String s="abcd";
byte[] bs=s.getBytes();
for(int i=0;i<bs.length;i++){
	System.out.print(bs[i]+“ ”);
}

   结果:97 98 99 100         

        将字符串按照指定字符集转成字节数组

String s="abcd";
byte[] bsS=s.getBytes("UTF-8");
for(int i=0;i<bsS.length;i++){
	System.out.print(bsS[i]+" ");
}

  结果: 97 98 99 100
        字符串转换成字符数组  

String s="abcd";
char[] bs=s.toCharArray();
for(int i=0;i<bs.length;i++){
	System.out.print(bs[i]+" ");
}

    结果: a b c d

        将字符串的部分字符转换成字符数组  s.getChars(first,end,c,c-first);

                                                                 参数1:字符串开始下标

                                                                 参数2:字符串结束下标

                                                                 参数3:字符数组

                                                                 参数4:字符数组开始下标

String s="abcd";
char []bss={'0','1','2','3','4','5'};

s.getChars(1, 3, bss, 2);
for(int i=0;i<bss.length;i++){

    System.out.print(bss[i]+" ");

}

    结果:0 1 b c 4 5
 
        获得一个字符  char c = s.CharAt(下标);

String s="abcd";
char c = s.charAt(2);
System.out.println(c);

    结果:c
  
        按字典顺序比较两个字符串 compareTo(String anotherString) 
        按字典顺序比较两个字符串，不考虑大小写   compareToIgnoreCase(String str)

        当且仅当此字符串包含指定的 char 值序列时，返回 true  contains(CharSequence s) 

       

String s="abcd";
String ss="ABcd";
String sx="bgj";
System.out.println(s.compareTo(ss));
System.out.println(s.compareTo(sx));
System.out.println(s.compareToIgnoreCase(ss));

   结果:

          32
          -1
          0
         
        判断字符串是不是以某一个后缀结尾   endsWith(String s);
        判断字符串是不是以某一个前缀开头   startsWith(String s);

       

String s="abcd";
System.out.println(s.endsWith("ab"));
System.out.println(s.endsWith("cd"));
System.out.println(s.startsWith("ab"));
System.out.println(s.startsWith("cd"));

    结果:

          false
          true
          true
         false
  
       判断两个字符串是否相等   equals(String s);
       判断两个字符串是否相等,忽略大小写   equalsIgnoreCase(String s);

      

String s="abcd";
String t="ABcd";
System.out.println(s.equals(t));
System.out.println(s.equalsIgnoreCase(t));

    结果:

           false
           true
  
       返回指定子字符串在此字符串中第一次出现处的索引 int t = indexOf(String str)
       返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始 int t = indexOf(String str, int fromIndex)

        参数1:指定字符串

        参数2:搜索开始下标

      

String s="abcdabjhgab";
System.out.println(s.indexOf("ab"));
System.out.println(s.indexOf("ab", 2));

    结果:

           0
           4
  
       返回指定子字符串在此字符串中最后一次出现处的索引 int t = lastindexOf(String str);

String s="abcdabjhgab";
System.out.println(s.lastIndexOf("ab"));

    结果:9
  
       得到字符串的长度

String s="abcdabjhgab";
int len  = s.length();
System.out.println(len);

   结果:11

       替换字符串   String t = s.replace(被替换字符串,替换字符串);
       String t1 = s.replacefirst(被替换字符串,替换字符串);

String s="abcdabjhgab";
String t=s.replace("ab", "01");
String t1=s.replaceFirst("ab", "01");
System.out.println(t);
System.out.println(t1);

    结果:

          01cd01jhg01
          01cdabjhgab

      
       截取字符串   s.substring(beginIndex);
                           s.substring(beginIndex,endIndex);

                              参数1:开始下标

                              参数2:结束下标(最后只会到达[结束下标-1]的位置)

String s="abcdabjhgab";
System.out.println(s.substring(2));
System.out.println(s.substring(2, 5));

   结果:

          cdabjhgab
          cda

       
      全部转换成小写字母  String t = s.toLowerCase();
      全部转换成大写字母  String t = s.toUpperCase();

String s="abCDabGgab";
System.out.println(s.toLowerCase());
System.out.println(s.toUpperCase());

   结果:

          abcdabggab
          ABCDABGGAB
  
      去掉字符串首尾的空白字符 String t = s.trim();

String s="   gc   ab  hj  ";
System.out.println("**"+s.trim()+"**");

   结果:**gc   ab  hj**

      将其他对应的类型装换成字符串  String t = String.valueOf(任意类型);

int a=10;
float b=2.3f;
double c=5.6d;
char d = '9';
System.out.println(String.valueOf(a));
System.out.println(String.valueOf(b));
System.out.println(String.valueOf(c));
System.out.println(String.valueOf(d));

 
 
      切割字符串  String[] t = s.splite(切割标记);

String s= "hg,aHG,Fh,gfhg";
String[] t=s.split(",");
for(int i=0;i<t.length;i++){
	System.out.println(t[i]);
}

   结果:

          hg
          aHG
          Fh
          gfhg

以上这些类几乎是我们平时用的最多的类了。