Java中的常用类

1      常用类NO13

1.1    封装类

【

Int    Interger

short  Short

byte   Byte

double Double

float   Float

Boolean Boolean

Char    Character

】

封装类都是引用类型，并且也具有对应基本数据类型的数学运算特征

 

装箱：   将基本数据类型的值装进封装类对象中去，也可以说把基本数

据类型转为封装类型

封装类名.valueOf(基本数据类型的值)

这个方法是静态方法，参数是基本数据类型的值，返回对应的封装类型对象

【Integeri2 = Integer.valueOf(2);  //属于类的静态方法】

拆箱：

【Integerinteger = Integer.valueOf(1000);//装箱

                   inti = integer.intValue();//拆箱      与对象相关的实例方法】

     把封装类对象转换为基本数据类型变量，这个过程就像把一个箱子（封装类）拆开，拿出里面装着的基本数据类型变量(将封装类型转换为基本数据类型)

xxxValue()    不是静态方法，用封装类对象去调用，返回一个基本数据类型的值，就是封装了值。

 

自动装箱：

【Integerinteger = 1000;  //自动装箱】

 

         直接将基本数据类型的值赋给对应的封装类的对象

         这种方式和valueOf(…)方法完全一样

 

自动拆箱：

【Integerinteger =Integer.valueOf(10000);

                   //直接将封装类型对象赋给对应的基本数据类型变量

                   inti = integer;】

         直接将封装的对象赋给对应的基本数据类型的变量

         这种方式和xxxValue()完全一样

 

用构造方法也能装箱，但没有缓存效果，一般不会这么用

 

静态方法parseXXX(String  s)用来将字符串转换为数字类型

【/*String s ="12345";

                   //将字符串转换为整型

                   int i = Integer.parseInt(s);】

 

toString()重写了，返回的是封装的值得字符串形式

静态方法toString(XXX X)将基本数据类型转换为字符串

静态方法toHexString(XXX  X)           ) //十六进制

静态方法toBinaryString (XXX  X)  //二进制

静态方法toOctalString (XXX  X)   //八进制

静态方法.toString(i, 2)                  //灵活，任何进制转换

reverse()

 

【注意：

         //装箱或自动装箱会将-128到127进行缓存，这个范围的封装

                   //类对象只会有一份

//缓存，静态区域

Integer i3 = 100;

                   Integer i4 = 100;//i3和i4都在静态区中缓存的封装类对象

                   System.out.println(i3== i4);     //返回true

Integer i5 = newInteger(100);

                   //i5和i6指向堆区中new出来不同的对象，不可能相同

                   Integer i6 = newInteger(100);

                   System.out.println(i5 == i6);    //返回false

】

1.2    String 

字符串(字符串是常量值)

字符串对象在创建后不能再更改

   

equals 比较两个字符串是否相同，大小写敏感

equalsIgnoreCase 字符串比较时无视大小写

trim()  去掉首尾的空格和回车换行字符，生成一个新的字符串（原来字符串对象并没有被改变）

 

在实际开发中永远用equals,

 

可以使用String contain(String s)参数是要和当前字符串拼接的字符串，返回的是拼接后新的字符串(原来的两个字符串都没有变

也可以进行+来拼接)

 

如果大量的字符串拼接，应该使用StringBuilder<线程不安全>、StringBuffer<>,可以避免产生大量的中间字符串

 

String substring(int start):从参数中的下标开始，获取子字符串(原来的字符串不变，返回的字符串是新的字符串)

 

Length()可以获取字符串的长度

 

char[]toCharArray()   返回这个字符串的字符数组

 

charcharAt(int index)  返回某个位置的字符

 

intindexOf(char c)    根据字符获取下标

intindexOf(char c,int fromIndex)    根据字符获取下标

int  indexOf(String  s)

int  indexOf(String  s, int fromIndex)

 

booleancontain(String s) 判断当前字符串是否以参数中的字符串（包含）

 

booleanstartsWith(String  s) 判断当前字符串是否以参数中的字符串开头

 

booleanendsWith(String  s)  判断当前字符串是否以参数中的字符串结尾

 

String[]  split(String s)   将调用这个方法的字符串以参数中的字符串为分隔符(

暂时这么理解，其实是正则表达式)，拆分成一个字符串数组返回出来（）

 

正则表达式：

【不是语言也不是框架，只是一种格式，可以用来判断一个字符串是否满足某种格式】

boolean matches (String  regex):判断当前字符串是否匹配参数中的正则表达式字符串

 

       拿Integer来说，int intValue()将调用这个方法的封装类对象拆箱，并拿出其中的基本数据类型变量，并返回

 

     自动拆箱：通过=将封装类型对象赋给基本数据类型变量，这样可以自动将封装类型拆箱成基本数据类型，相当于隐式调用了intValue()

 

 

 

 

字符串转数字：

            Integer的静态方法int parseInt(String str)可以将表示数字的字符串str转为int，如果参数字符串不是有效的数字形式，那么会抛出NumberFormatException

 

 

1.3    Math

Math：数学工具类，有很多静态方法,其中都是静态方法和静态属性

  random() 生成[0,1)之间的随机数

  round() 四舍五入

  floor(double a) 返回小于等于a的最大整数值

  ceil(double a) 返回大于等于a的最小整数值

  abs() 取绝对值

  pow(double a,double b) a的b次方

  sqrt(double a)a的平方根

max

min

 

  PI 圆周率

  E 自然对数底数

 

1.4    Date

Date 日期类

new Date() 创建表示当前时间的日期对象

toString() 返回默认格式日期字符串

getTime()  返回绝对时间毫秒数

SimpleDateFormat 简单日期格式类，可以用来格式化输出日期对象，也

可以将一个格式化了的日期转化回一个日期对象

Date d = new Date();

SimpleDateFormat f =new SimpleDateFormat("yy-MM-dd hh:mm:ss")

String s =f.format(d);格式化日期成字符串

 

Date date =f.parse(str);解析成日期对象

 

Calendar

 

 

 

 

 

String：字符串

  boolean equals(Object o)  比较当前字符串和参数中的字符串是否相等

  booleanequalsIgnoreCase(String str)忽略大小写的字符串比较

  int compareTo(String) 按照字典顺序比较当前字符串和参数中的字符串

  char charAat(int index) 返回下标为index位置的字符（）从0开始

  int length() 字符串的长度

  StringsubString(int index) 返回一个从index位置开始的子字符串

  Stringconcat(String str) 把当前的字符串和参数字符串连接起来，生成一个新的字符串返回

  在需要大量拼接字符串时，这种方式（以及+的方式）会生成大量字符串对象，浪费内存，这时我们可以使用StringBuilder或StringBuffer来拼接字符串

      StringBuffer:  内置一个缓冲，可以不添加字符串而不用生成新的字符串对象

                 append(String str)  在缓冲后添加字符串

                 toString()          最终生成一个拼接好了的字符串

 

      StringBuilder:和StringBuffer基本一样，只是StringBuffer线程安全、StringBuilder线程不安全，但效率高

 

  String[] split(String str) 拆分当前字符串，以参数作为分割符号，返回一个拆分后的字符串数组（如果要用.作为分割符，必须转义，用\\.）

 

  boolean contains(CharSequence s) 当前字符串是否包含参数中的字符序列

  boolean startsWith当前字符串是否以参数中字符串开始

  boolean endsWith 当前字符串是否以参数中字符串结尾

 

 

 

 

Date：日期类

     构建     new Date()   构建的是当前的日期时间

    toString()  返回一个表示这个日期时间的字符串

    long getTime()   返回从1970年1月1日0点00分到这个日期时间的毫秒数

 

1.5    Canlendar

 

Canlendar：日历类

  get()  可以具体获得某个值（年、月、日...）

  set(int field,intvalue) 将某个属性（年、月、日）改为指定值

  add(int field,intvalue) 将某个属性（年、月、日）加上指定值

 

SimpleDateFormat  日期格式化

1.6    代码片段总结

1：用“==”判断字符串是否相等，实质是判断引用是否指向同一对象

【

//用"XXX"方式创建的字符串对象位于静态区常量池

                   Strings1 = "android";//第一次出现会在常量池里创建

                   Strings2 = "android";//第二次出现会直接使用常量池中

                   //s1和s2是否指向同一个对象，这里指向同一个

                   System.out.println(s1== s2);

                  

                   //用new的方式创建的字符串对象位于堆区，new一次创建一次

                   Strings3 = new String("android");//第一次创建

                   Strings4 = new String("android");//第二次还要创建一个

                   System.out.println(s3== s4);   //false

】

2：比较封装类对象可以使用equals

【

         Integer i1 =1000;

   Integer i2 = 1000;

   System.out.println(i1.equals(i2));//返回true

】

3:整型封装类与进制间的转换

【

         int i = 11;

         Integer.toBinaryString(i)   //二进制

         Integer.toHexString(i)     //十六进制

         Integer.toOctalString(i)    //八进制

         Integer.toString(i,2)      //灵活，任何进制转换

】

4：切割字符串与数组的联合运用

【

         /*二.将给定字符串str="1,2,3!4,5,6,0!7,8,9"存入二维数组中。

String str ="1,2,3!4,5,6,0!7,8,9";

                   String[]outer = str.split("!");

                   int[][]array = new int[outer.length][];

                   for(inti=0;i<outer.length;i++){

                            String[]inner = outer[i].split(",");

                            array[i]=newint[inner.length];

                            for(intj=0;j<inner.length;j++){

                                     array[i][j]=Integer.parseInt(inner[j]);

                            }

String str ="1,2,3!4,5,6,0!7,8,9";

                   String[]outer = str.split("!");

                   String[][]array = new String[outer.length][];

                   for(inti=0;i<outer.length;i++){

                            String[]inner = outer[i].split(",");

                            array[i]= inner;

                   }

】

5：字符串综合实例操作

【

/*三.

 1、让用户不停输入字符串并拼接起来，用逗号分隔，如果输入exit则停止输

 入，最后拼成一个长字符串，使用StringBuilder

 2、将这个拼成的长字符串中所有的数字替换成*，并打印出来

 3、打印这个字符串的最后3个字符*/

         public staticvoid main(String[] args) {

                   Scanners = new Scanner(System.in);

                   StringBuilderb = new StringBuilder();

                   while(true) {

                            Stringline = s.nextLine();

                            if(line.equals("exit"))

                                     break;

                            b.append(line);

                            b.append(",");

                   }

                   Stringr = b.toString();

                   System.out.println(r);

                   System.out.println(r.replaceAll("[0-9]","*"));

                   System.out.println(r.substring(b.length()- 3));

         }

】

6：日历时间计算小练习

【/*四.让用户输入三个数字表示年、月、日，输出这年月日代表的日期是星期几*/

         public staticvoid main(String[] args) {

                   Scanners = new Scanner(System.in);

                   intyear = s.nextInt();

                   intmonth = s.nextInt();

                   intday = s.nextInt();

                   Calendarc = Calendar.getInstance();

                   c.set(Calendar.YEAR,year);

                   c.set(Calendar.MONTH,month - 1);

                   c.set(Calendar.DAY_OF_MONTH,day - 1);

                   System.out.println(c.get(Calendar.DAY_OF_WEEK));

         }

】