Java SE 06 常用类

1.    字符串相关类（String、StringBuffer）

String类

StringBuffer类

 

2.    基本数据类型包装类

基本类型内存分配在栈中，包装类分配在堆中

/**
解析字符串参数"1,2;3,4,5;6,7,8"返回double型二维数组
*/
public class ArrayParser {
       public static void main(String[] args) {
              double[][] d;
              String s = "1,2;3,4,5;6,7,8";
              String[] sFirst = s.split(";");
              d = new double[sFirst.length][];
              for(int i=0; i<sFirst.length; i++) {
                     String[] sSecond = sFirst[i].split(",");
                     d[i] = new double[sSecond.length];
                     for(int j=0; j<sSecond.length; j++) {
                           
                            d[i][j] = Double.parseDouble(sSecond[j]);
                           
                     }
              }
             
              for(int i=0; i<d.length; i++) {
                     for(int j=0; j<d[i].length; j++) {
                            System.out.print(d[i][j] + " ");
                     }
                     System.out.println();
              }
       }
}

3.    Math类

4.    File类

package com.file;
 
import java.io.File;
import java.io.IOException;
/**
 * 创建一系列路径并创建文件
 */
public class FileTest {
       public static void main(String[] args) {
             
              String seperator = File.separator;  //获取当前系统下的分隔符
              String fileName = "myfile.txt";
              String directory = "mydir1"+seperator+"mydir2";
             
              File f = new File(directory,fileName);  //创建一个新的File对象
              if(f.exists()) {
                     System.out.println("文件名:"+f.getAbsolutePath());  //绝对路径
                     System.out.println("文件大小"+f.length());
              }else {
                     f.getParentFile().mkdirs();  //在父路径下建一系列路径
                     try {
                            f.createNewFile();            //创建一个空的新文件
                     } catch (IOException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                     }
              }
             
       }
}
/*
运行两次：
 文件名:D:\eclipse-workspace\File\mydir1\mydir2\myfile.txt
文件大小0
 */
 

package com.file;
 
import java.io.File;
 
/**
 * 递归列出目录结构
 * 在控制台以树状结构展现特定的文件夹及其子文件（夹）
 */
public class FileList {
       public static void main(String[] args) {
              File f = new File("e:/A");    //windows下或"e:\\A"
              System.out.println(f.getName());
              tree(f,1);
       }
      
       private static void tree(File f,int level) {
              //第几层打印几个（四个空格）
              String preStr = "";
              for(int i = 0; i < level; i++) {
                     preStr = preStr + "    ";
              }
             
              File[] childs = f.listFiles();
              for(int i = 0; i < childs.length; i++) {
                     System.out.println(preStr+childs[i].getName());
                     //判断子目录（文件）是否还是目录
                     if(childs[i].isDirectory()) {
                            tree(childs[i],level+1);
                     }
              }
       }
}
/*
A
    b
        d
        e
            g.txt
        f.docx
    b1
    c.txt
 * */

5.    枚举类

只能取特定值中的一个

使用enum关键字

java.lang.Enum类型

package com.e;
 
public class EnumTest {
      
       public enum MyColor {
              red,green,yellow
       }
      
       public static void main(String[] args) {
              MyColor mc = MyColor.green;  //这里的取值有限制
              System.out.println(mc);
       }
}
/*
 green
 */

6.    总结

String相关 （String、StringBuff）

            正则表达式

基础类型包装类（四类八种）

Math（random…）

File

            递归

枚举类型

[要经常查API文档]

4.1 基本类型的封装

1.基本类型的封装类各自是什么？如何使用这些封装类？

基本类型与封装类的最大区别是，封装类是引用类型，其实问题就是基本类型和引用类型的区别。
基本类型在内存中是存储在栈中，引用类型的引用（值得地址）存储在栈中，而值是存储在堆中。

基本类型与其封装类型对应的关系如下：

byte------Byte; short------Short; int------Integet;  long------Long;  float------Float; double------Double;  boolean------Boolean;  char------Character

基本类型的值转化成封装类对象时，有两种方法：

v 直接用new方法创建封装类对象，参数为基本类型的值。

v 使用封装类的valueOf静态方法，参数为基本类型的值，返回封装类对象。

封装类转换为基本类型的值时，有一种方法：

使用封装类对象的xxxValue实例方法，返回它的基本类型值。

// 基本类型byte转换为包装类型的方法
 private Byte byte2Byte(byteb) {
  Byte by = new Byte(b);
  // Byte by =Byte.valueOf(b);
  return by;
 }
 // 包装类型Byte装换位基本类型
 private byte Byte2byte(Byteb) {
  if (b == null) {
   return 0;
  } else {
   return b.byteValue();
  }
 }

4.2Object类
4.3字符串类

1.Object类与其他类的关系？

Object类是一切java类的父类，对于普通的java类，即便不声明，也是默认继承了Object类。典型的，可以使用Object类中的toString()方法

1.   Object类与基本数据封装类、自定义类各自的equals方法与“==”的含义？

值类型是存储在内存中的堆栈（以后简称栈），而引用类型的变量在栈中仅仅是存储引用类型变量的地址，而其本身则存储在堆中。

      ==操作比较的是两个变量的值是否相等，对于引用型变量表示的是两个变量在堆中存储的地址是否相同，即栈中的内容是否相同。       equals操作表示的两个变量是否是对同一个对象的引用，即堆中的内容是否相同。

       ==比较的是2个对象的地址，而equals比较的是2个对象的内容。显然，当equals为true时，==不一定为true。

1.   String与StringBuffer的区别？

在java中有3个类来负责字符的操作。

 1.Character 是进行单个字符操作的，

 2.String对一串字符进行操作。不可变类。

 3.StringBuffer 也是对一串字符进行操作，但是可变类。

 String: 

是对象不是原始类型. 为不可变对象,一旦被创建,就不能修改它的值.  对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去. String 是final类,即不能被继承.

StringBuffer: 

是一个可变对象,当对他进行修改的时候不会像String那样重新建立对象 它只能通过构造函数来建立,

StringBuffer sb = new StringBuffer();

note:不能通过付值符号对他进行付值. 

sb = "welcome to here!";//error

 对象被建立以后,在内存中就会分配内存空间,并初始保存一个null.向StringBuffer 中付值的时候可以通过它的app end方法.

 sb.append("hello"); 

字符串连接操作中StringBuffer的效率要比String高:

 String str = new String("welcome to");
 str+= "here"; 

的处理步骤实际上是通过建立一个StringBuffer,然后调用append(),最后 再将StringBuffer toSting(); 

这样的话String的连接操作就比StringBuffer多出了一些附加操作,当然效率上要打折扣. 并且由于String对象是不可变对象,每次操作Sting 都会重新建立新的对象来保存新的值. 这样原来的对象就没用了,就要被垃圾回收.这也是要影响性能的.

2.   String类常用的方法有哪些？

 

3.   String类型的数据与基本数据类型直接如何转换？

一、基本数据类型to字符串类型(包含char类型)

（1）toString   　　

　　①基本数据类型的都有一个静态方法toString()，转换时可以采用 "封装类型.toString(对应的基本数据类型字面值)" 方法来转换成字符串。

　　　　例：将int类型的20转成字符串，

String s = Int.toString(20)

　　②将基本数据类型封装成相应的封装类型对象，采用 "基本数据类型对象.toString()"方法转换成字符串。

　　　　例：将double类型的425.0转成字符串，

Double d = new Double(425.0);    String s =d.toString();

（2）+""，将基本数据类型字面值与空字符串""通过"+"连接

　　例：将long类型的200转成字符串，

String s = 200 + "";

（3）valueOf，利用String类的静态方法valueOf()。

　　例：将char类型的'b'转成字符串，

String.valueOf('b');

二、字符串to基本数据类型(不包含char类型)

（1）利用基本数据类型包装类的parseXxx方法

　　例：将字符串"123"转成int类型，

int i =Integer.parseInt("123");

（需注意字符串转成基本数据类型时字符串内容必须是基本数据类型的字面值，否则编译虽然能通过，但运行时出现NumberFormatException）

（2）用字符串构造基本类型的封装对象，再调用封装对象的xxxValue方法

　　例：将字符串"20.5"转成double类型，

Double d1 = newDouble("20.5");　　double d2 =d1.doubleValue();

1.   String与toString的区别？

(String)

这是标准的类型转换，将object转成String类型的值。使用这种方法时，需要注意的是类型必须能转成String类型。因此最好用instanceof做个类型检查，以判断是否可以转换。否则容易抛出CalssCastException异常。此外，需特别小心的是因定义为Object 类型的对象在转成String时语法检查并不会报错，这将可能导致潜在的错误存在。这时要格外小心。如：

Object obj = new Integer(100);

String strVal = (String)obj;

在运行时将会出错，因为将Integer类型强制转换为String类型，无法通过。、

toString

在这种使用方法中，因为java.lang.Object类里已有public方法.toString()，所以对任何严格意义上的java对象都可以调用此方法。但在使用时要注意，必须保证object不是null值，否则将抛出NullPointerException异常。采用这种方法时，通常派生类会覆盖Object里的toString（）方法。

2.Object与基本数据封装类中的toString的含义？

1.某些情况下，数据必须作为对象出现,此时必须使用封装类来将简单类型封装成对象。

比如，如果想使用List来保存数值，由于List中只能添加对象，因此我们需要将数据封装到封装类中再加入List。在JDK5.0以后可以自动封包，可以简写成list.add(1)的形式，但添加的数据依然是封装后的对象。

另外，有些情况下，我们也会编写诸如func(Object o)的这种方法，它可以接受所有类型的对象数据，但对于简单数据类型，我们则必须使用封装类的对象。

2.某些情况下，使用封装类使我们可以更加方便的操作数据。

比如封装类具有一些基本类型不具备的方法，比如valueOf(), toString(), 以及方便的返回各种类型数据的方法，如Integer的shortValue(), longValue(), intValue()等。

3.基本数据类型与其对应的封装类由于本质的不同，具有一些区别：

基本数据类型只能按值传递，而封装类按引用传递。

基本类型在堆栈中创建；而对于对象类型，对象在堆中创建，对象的引用在堆栈中创建。基本类型由于在堆栈中，效率会比较高，但是可能会存在内存泄漏的问题。

 

 

4.4Scanner类

1.Scanner类的作用？如何使用？
2.Scanner类的常用方法有哪些？可以用来获取哪些类型的输入？获取方法分别是什么？

Scanner类，一个可以使用正则表达式来解析基本类型和字符串的简单文本扫描器。

用于扫描输入文本的实用程序。位于java.util包中。

使用Scanner接收键盘输入的字符，步骤：

1.导入Scanner类。

　　import java.util.Scanner;

2.创建Scanner对象。

　　Scanner input=new Scanner(System.in);

3.获得键盘输入的数据。

　　int i=input.nextInt();
Strings=input.next();
doubled=s.nextDouble();
　　Double d=double.nextDouble();
　　Boolean b=boolean.hasNext();//判断是否有输入的数据，有则返回true，没有就返回false。