jave se基础复习2

 

常用类

字符串相关类(String ,StringBuffer)

 Java.lang.String类代表不可变的字符序列

 “xxxx”为该类的一个对象

   String类的常见构造方法:

     String(String original) 创建一个String对象为original的拷贝

        String(char[] value) 用一个字符数据创建一个String对象

     String(char[] value,int offset,int count) 用一个字符数组从offset项开始的count个字符序列创建一个String对象.

Eg public class test{

 Public static void main(String[] args){

 String s1 = “hello”;

 String s2 = “world”;

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

 

 S1= new String(“hello”);

S2=new String(“hello”);

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

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

 

Char c[] ={‘s’,’u’,’n’,’’,’j’,’a’,’v’,’a’};

String s4=new String(c);

String s5=new String(c,4,4);//从第四个字符开始截四个字符

System.out.println(s4);

System.out.println(s5);

}

}

String类常用方法

Public char charAt(int index) 返回字符串中第index个字符

Public int length() 返回字符串长度

Public int indexOf(string str) 返回字符串中出现str的第一个位置

Public int indexOf(string str,int fromIndex) 返回字符串中从fromIndex开始出现str的第一个位置

Public Boolean equalsIgnoreCase(string another) 比较字符串与another是否一样(忽略大小写)

Public string replace(char oldChar,char newChar) 在字符串中用newChar字符替换oldChar字符

Eg:

Public class test{

 Public static void main(String[] args){

 String s1=”sun java”,s2=”Sun Java”;

 System.out.println(s1.charAT(1));//u

 System.out.println(s1.length);//8

System.out.println(s1.indexOf(“java”));//4

System.out.println(s1.indexOf(“Java”));//-1

System.out.println(s1.equals(s2));//false

System.out.println(s1.equalsIgnoreCase(s2));//true

 

String s=” 我是程序员,我在学java”;

String sr=s.replace(‘我’,’你’);

System.out.println(sr);//你是程序员,你在学java

}

}

 

Public Boolean startsWith(string prefix)判断字符串是否以prefix字符串开头

Public Boolean endsWith(string suffix)判断字符串是否以prefix字符串结尾

Public String toUpperCase()返回一个字符串为该字符串的大写形式

Public string toLowerCase()返回一个字符串为该字符串的小写形式

Public string substring(int beginIndex)返回该字符串从beginIndex开始到结尾的子字符串

Public string substring(int beginIndex,int endIndex)返回该字符串从beginIndex开始到endIndex结尾的子字符串

Public string trim()返回该字符串去掉开头和结尾空格后的字符串

Eg

Public class Test{

 Public static void main(string[] args){

 String s= “Welcome to Java World”;

 String s1=” sun java ”;

System.out.println(s.startsWith(“Welcome”));//true

System.out.println(s.endsWith(“World”));//false

 

String sL = s.toLowerCase();

String sU= s.toUpperCase();

System.out.println(sL);

System.out.println(sU);

String sp = s1.trim();

System.out.println(sp);//sun java

}

}

 

Public static String valueOf()可以将基本类型转化为string类型

Public String[] split(String regex)可以将一个字符串按照指定的分隔符分隔,返回分隔后的字符串数组.

Eg

Public class test{

 Public static void main(String[] args){

 Int j = 1234567;

 String sNumber = string.valueOf(j);

 System.out.println(“j是”+sNumber.length()+”位数.”);

 String s = “Mary,f,1976”;

 String[] sPlit = s.split(“,”);

 For(int i=0;i<sPlit.length;i++){

 System.out.println(sPlit[i]);

}

}

}

 

Eg 1:编写一个程序,输出一个字符串中的大写英文字母数,小写英文字母数以及非英文字母数

Public class TestString{

 Public static void main(String[] args){

 String s = “AaaaABBBB&^%adfsfdCCOOkk99876 _haHA”;

 int lCount = 0,ucount = 0,oCount = 0;

 For(int i=0;i<s.length();i++){

   Char c = s.charAt(i);

   If(c>=’’a && c<=’z’){lCount++;}

   Else if(c>=’A’&&c<=’z’){uCount++;}

Else{oCount++}

}

System.out.println(lCount+” ” + uCount +” “+ oCount );

}

}

 

方法二

String sL=”abcdefghijklmnopqrstuvwxyz”;

String sU=”ABCDEFGHIJKLMNOPQRSTUVWXYZ”;

For(int i=0;i<s.length();i++){

 Char c = s.charAt(i);

 If(sL.indexOf(c) !=-1){

 lCount++;

}else if(sU.indexOf(c)!=-1){

 uCount++;

}else{

 oCount++;

}

}

2:编写一个方法,输出在一个字符串中,指定字符串出现的次数

String s=”sunjavahpjavaokjavajavahahajavajavagoodjava”;

String sToFind=”java”;

Int count =0;

Int index=-1;

While((index=s.indexOf(sToFind))!=-1){

 S=s.substring(index+sToFind.length());

 Count++;

}

System.out.println(count);

基本数据类型包装类

Math类

File类

枚举类

StringBuffer类

Java.lang.StringBuffer代表可变的字符序列

StringBuffer和String类似,但StringBuffer代表可以对其字符串进行改变

StringBuffer类的常见构造方法:

 StringBuffer()创建一个不包含字符序列的StringBuffer对象

 StringBuffer(String str)创建一个StringBuffer对象,包含String对象str相同的字符序列

StringBuffer常用方法

重载方法public stringBuffer append()可以为该stringBuffer对象添加字符序列,返回添加后的该stringBuffer对象引用

Public stringBuffer insert()可以为该stringBuffer对象在指定位置插入字符序列,返回修改后的该stringBuffer对象引用.eg public StringBuffer insert(int offset,string str)

                        Public StringBuffer insert(int offset,double d)

Public stringBuffer delete(int start,int end)可以删除从start开始到end-l为止的一段字符序列,返回修改后的该stringBuffer对象引用.

和String类含义类似的方法:

 Public int indexOf(String str)

 Public int indexOf(String str,int fromIndex)

Public String substring(int start)

Public String substring(int start,int end)

Public int length()

方法public StringBuffer reverse()用于将字符序列逆序,返回修改后的该StringBuffer对象引用

Eg public class Test{

   Public static void main(String[] args){

 String s = “Mircosoft”;

 Char[] a = {‘a’,’b’,’c’};

 StringBuffer sb1 = new StringBuffer(s);

 Sb1.append(‘/’).append(“IBM”).append(‘/’).append(“Sun”);

System.out.println(sb1);

StringBuffer sb2 = new StringBuffer(“数字”);

For(int i=0;i<=9;i++){sb2.append(i);}

System.out.println(sb2);

Sb2.delete(s,sb2.length()).insert(0,a);

System.out.println(sb2);

System.out.println(sb2.reverse());

}

}

输出结果:Mircosoft/IBM/Sun

        数字0123456789

        abc数字012345

        543210字数cba

基础数据类型包装类

每一个基础数据类型一般都分配在栈上,如果想让他分配在堆上,使用基础数据类型包装类

 Interger float Boolean character

包装类(如:Integer,Double等)这些类封装了一个相应的基本数据类型数值,并为其提供了一系列操作.

Java.lang.Integer类为例,构造方法:

 Integer(int value)

 Integer(String s)

ParseLong() toHexString() toOctalString()

valueOf()字符串转换成基础数据类型包装类

Long类型数封装成long类型对象 new Long(long value)

Long类型对象转换成long类型数longValue()

Long类型转换成int类型intValue()

Java.lang.Integer为例

Public static final int MAX_VALUE最大的int型数

Public static final int MIN_VALUE最小的int型数

Public long longValue()返回封装数据的long型值

Public double doubleValue()返回封装数据的double型值

Public int intValue()返回封转数据的int型值

Public static int parseInt(String s)throws NumberFormatException返回Integer对象,其中封装的整型数据为字符串s所表示.

Eg public class Test{

   Public static void main(String[] args){

 Integer I = new Integer(100);        //long类型数封装成long类型对象

 Double d = new Double(“123.456”); //字符串封装成double类型对象

 int j=i.intValue()+d.intValue();      //int类型对象转换成int类型数

 float f=i.floatValue()+d.floatValue();

 System.out.println(j);System.out.println(f);

 double pi=Double.parseDouble(“3.1415926”); //字符串转换成double类型数

 double r=Double.valueOf(“2.0”).doubleValue();//字符串转换成基础数据类型包装类对象,再转换成相应类型数

 double s= pi*r*r;

 System.out.println(s);

 Try{

  int k=Integer.parseInt(“1.25”);

}catch(NumberFormatException e){

 System.out.println(“数据格式不对!”);

}

System.out.println(Integer.toBinaryString(123)+”B”);

System.out.println(Integer.toHexString(123)+”H”);

System.out.println(Integer.toOctalString(123)+”O”);

}

}

Eg 编写一个方法,返回一个double型二维数组,数组中的元素通过解析字符才串参数获得.如字符串参数:”1,2;3,4,5;6,7,8”

对应的数组为:d[0,0]=1.0 d[0,1]=2.0

             D[1,0]=3.0 d[1,1]=4.0 d[1,2]=5.0

             D[2,0]=6.0 d[2,1]=7.0 d[2,2]=8.0 

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();

}

}

}

Math类

Java.lang.Math提供了一系列静态方法用于科学计算;其方法的参数和返回值类型一般为double型.

abs绝对值

acos,asin,atan,cos,sin,tan

sqrt平方根

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

log自然对数

exp e为底指数

max(double a,double b)

min(double a,double b)

random()返回0.0到1.0的随机数

long round(double a) double型的数据a转换为long型(四舍五入)

toDegrees(double angrad)弧度->角度

toRadians(double angdeg)角度->弧度

File类

Java.io.File类代表系统文件名(路径和文件名),不代表实际的物理文件

File类常见构造方法

public File(String pathname)以pathname为路径创建file对象,如果pathname是相对路径,则默认的当前路径在系统属性user.dir中存储

public File(String parent,String child)以parent为父路径,child为子路径创建file对象

file的静态属性String separator存储了当前系统的路径分隔符(\)

windows下反斜杠\linux下正斜杠/(win和lin下永远写正斜杠都没问题)

file类常用方法:

 通过file对象可以访问文件的属性

Public boolean canRead()

Public boolean canWrite()

Public Boolean exists() //查看硬盘上是否有这个文件

Public Boolean isDirectory() //查看是不是一个目录

Public Boolean isFile()

Public Boolean isHidden()

Public long lastModified() //上次修改的时间(一个固定时间到目前为止一共走过多少个毫秒数)

Public long length()

Public String getName()

Public String getPath()

通过file对象创建空文件或目录(在该对象所指的文件或目录不存在的情况下)

Public Boolean createNewFile() throws IOException

Public Boolean delete()

Public Boolean mkdir()

Public Boolean mkdirs()//创建在路径中的一系列目录

 

Eg public class TestFile{

Public static void main(String[] args){

 String separator=File.separator;

 String filename=”myfile.txt”;

 String directory=”mydir”+separator+”mydir2”;

 File f=new File(directory,filename);

 If(f.exists()){

 System.out.println(“文件名:”+f.getAbsolutePath());

 System.out.println(“文件大小:”+f.length());

}

Else{

f.getParentFile().mkdirs();

try{

 f.createNewFile();

}catch(IOException e){

 e.printStackTrace();

}

}

}

}

Eg 编写一个程序,在命令行中以树状结构展现特定的文件夹及其子文件(夹)

Public class FileList{

 Public static void main(String[] args){

 File f = new File(“d:/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 +=”    “;

}

 File[] childs = f.listFile();

 For(int i=0;i<childs.length;i++){

 System.out.println(childs[i].getName());

 If(childs[i].isDirectory){

 Tree(childs[i]);

}

}

}

}

Java.lang.Enum枚举类型

枚举类型:

 只能够去特定值中的一个

 使用enum关键字

 是java.lang.Enum类型

Eg public class TestEnum{

Public enym MyColor{red,green,blue};

Public static void main(String[] args){

 Mycolor m=MyColor.red;

Switch(m){

 Case red:

 System.out.println(“red”);

Break;

     Case green:

      System.out.println(“green”);

      Break;

     Default:

      System.out.println(“default”);

}

System.out.println(m);

}

}

总结:

String 相关

 正则表达式

基础数据类型包装类

Math

File

 递归

枚举类型