八、java常用类

目录

一、字符串相关类

String类

StringBuffer类

二、基本数据类型包装类

三、Math类

四、File类

五、枚举类

一、字符串相关类

1.String类

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

“xxxx”为该类的一个对象

String类常见的构造方法：

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

看一个例子：

//测试类
public class Test {
    public static void main(String[] args){
        String s1 = "hello";
        String s2 = "world";
        String s3 = "hello";
        System.out.println(s1 == s3);
        s1 = new String("hello");
        s3 = new String("hello");
        System.out.println(s1.equals(s3));
        System.out.println(s1 == 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);
    }
}
//输出结果
//true
//true
//false
//sun java
//java

String类常用方法

public char charAt(int index)
//返回字符串中第index个字符
public int lenth()
//返回字符串长度
public int indexOf(String str)
//返回字符串中出现str的第一个位置
public int indexOf(String str, int fromIndex)
//返回字符串中从fromIndex开始出现str的第一个位置
public boolean equalsIgoreCase(String another)
//比较字符串与another是否一样（忽略大小写）
public String replace(char oldChar,char newChar)
//在字符串中用newChar字符串替换oldChar字符串




public boolean startWith(String prefix)


//判断字符串是否以prefix字符串开头


public boolean endsWidth(String suffix) 


//判断字符串是否一suffix字符串结尾


public String toUpperCase()


//返回一个字符串为该字符串的大写形式


public String toLowerCase()


//返回一个字符串为该字符串的小写形式


public String sunstring(int beginIndex,int endIndex)


//返回字符串从beginIndex开始到endIndex结尾的子字符串


public String trim()


//返回该字符串去掉开头和结尾空格后的字符串


看例子理解：


//测试类
public class Test {
    public static void main(String[] args){
        String s1 = "sun java";
        String s2 = "Sun java";
        System.out.println(s1.charAt(1));//u
        System.out.println(s2.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.print(sr);//你是程序员，你在学习java
    }
}


//测试类
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
        System.out.println(s.toLowerCase());//welcome to java world!
        System.out.println(s.toUpperCase());//WELCOME TO JAVA WORLD!
        System.out.println(s.substring(11));//Java World!
        System.out.println(s1.trim());//sun   java
    }
}



    

  • 静态重载方法
    • 



public static String valueOf(…)可以将基本数据类型转换为字符串；


例如：


public static String valueOf(double d)


Public static String value of(int i)


    

  • 方法public Strint[] split(String regex)可以将一个字符串按照指定的分隔符分割，返回分隔后的字符串数组
    • 




//测试类
public class Test {
    public static void main(String[] args){

        int i = 123456;
        String sNumber = String.valueOf(i);
        System.out.println(“i是”+sNumber.length()+”位数”);
        String s = "Nice to meet you";
        String[] sPlit = s.split(" ");
        for(int k=0;k<sPlit.length;k++){
            System.out.println(sPlit[k]);
        }
    }
}

//输出结果：

//i是7位数//Nice
//to
//meet
//you



2.StringBuffer类


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


StrinBuffer和String类似，但StringBuffer可以对其字符串进行改变。


这里说的可变指的是主要是内存空间，打比方你定义了一个String s1=”a”,s2=”b”如果要执行s1=s1+s2的话，在内存空间中会另外开辟出第三块内存，然后把s1和s2分别附加到第三块内存，再让s1指向第三块内存，完成附加流程。同样的，对于如果你想截取String里的部分字符也要开辟第三块内存空间


StringBuffer类的常见构造方法：



StringBuffer()//创建一个不包含字符序列的“空”的StringBuffer对象
StringBuffer(String str)//创建一个StringBuffer对象，包含与String对象str相同的字符串序列



重载方法


    

  • public StringBuffer append(…)可以为该StringBuffer对象添加字符串序列，返回添加后的该StrintBuffer对象引用，例如：
    • 



public StringBuffer append(String str)


public StringBuffer append(StringBuffer sbuf)


public StringBuffer append(char[] str)


public StringBuffer append(char[] str,int offset,int len)


public StringBuffer append(double d)


public StringBuffer append(object obj)


…


    

  • public StringBuffer insert(…)可以为该StringBuffer对象在指定位置插入字符串序列，返回修改后的该StringBuffer对象引用，例如：
    • 



public StringBuffer insert(int offset,String str)


public StringBuffer insert(int offset,double d)


…


    

  • public StringBuffer delete(int start,int end)可以删除从start开始到end-1为止的一段字符串序列，返回修改后的该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()用于将字符序列逆序，返回修改后的该S他ringBuffer对象引用
    • 



看一个例子：


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(8, sb2.length()).insert(0, a);
        System.out.println(sb2);

        System.out.println(sb2.reverse());
    }
}
//输出结果：
//Mircosoft/IBM/Sun
//数字: 0123456789
//abc数字: 0123
//3210 :字数cba



3.练习



//输出指定字符串中大写小写和特殊字符的出现次数
public class Test {
    public static void main(String[] args){

        String s = "AaaaAbbbbcc+-*adfsfdCCOOkk99876 *haHA";
        int big = 0,small = 0, specil = 0;
        for(int i = 0;i<s.length();i++) {
            char c = s.charAt(i);
            if(Character.isLowerCase(c)) {
                small++;
            }else if (Character.isUpperCase(c)) {
                big++;
            }else {
                specil++;
            }
        }
        System.out.println("小写"+small+"个");
        System.out.println("大写"+big+"个");
        System.out.println("特殊字符"+specil+"个");
    }
}


//输出指定字符串在另一个字符串中出现的次数
public class Test {
    public static void main(String[] args){

        String s = "sun java sun java sun java sun java ";
        String find="java";

        int count = 0;
        while(s.indexOf(find) != -1) {
            s = s.substring(s.indexOf(find) + find.length());
            count++;
        }
        System.out.print(count);
    }
}



二、基本数据类型包装类


包装类（如：Iteger，Double等）这些类封装了一个相应的基本数据类型数值，并为其提供了一系列操作。


以java.lang.Integer为例；构造方法：


    

  • Integer(int value)
    • 

  • Integer(String s)
    • 



包装类常见方法：


public static final int MAX_VALUE //最大的int型数（2的31次方-1）
public static final int MIN_VALUE //最小的int型数（-231）
public long longValu() //返回封装数据的long型值
public double doubleValue() //返回封装数据的double型值
public int intVlaue() //返回封装数据的int型值
public static int parseInt(String s) throwsNumberFormatException//将字符串解析成int型数据，并返回值
public static Integer valueOf(String s) shrows NumberFormatException //返回Integer对象，其中封装的整型数据为字符串s所表示


看一个例子：


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

        Integer i = new Integer(100);
        Double d = new Double("123.456");
        int j = i.intValue()+d.intValue();
        float f = i.floatValue()+d.floatValue();
        System.out.println(j);
        System.out.println(f);

        double pi = Double.parseDouble("3.1415926");
        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");
    }
}


public class Test {
    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]);
                //System.out.println(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,sin,stan,cos,sin,tan
sqrt //平方根
pow(double a,double b) //a的b次冥
log //自然对数
exp e //底指数
max(double a,double b)
min(double a,doublle b)
random() //返回0.0到1.0的随机数
long round(double a) //double型的数据a转换为long型（四舍五入）
toDegrees(double angrad) //弧度->角度
toRadians(double angdeg) //角度->弧度


看个例子：


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

        double a = Math.random();
        double b = Math.random();
        System.out.println(Math.sqrt(a*a+b*b));
        System.out.println(Math.pow(a, 8));
        System.out.println(Math.round(b));
        System.out.println(Math.log(Math.pow(Math.E,15 )));
        double d = 60.0 , r = Math.PI/4;
        System.out.println(Math.toRadians(d));
        System.out.println(Math.toDegrees(r));

    }
}



四、File类


java.io.File类代表系统文件名（路径和文件名）


常见构造方法：


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


File的静态属性String separator存储了当前系统的路径分隔符（windows下是反斜杠，linux下是正斜杠，为了跨平台使用，事实上，在windows上使用正斜杠也是可以的）


常见方法：


//通过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() //创建在路径中的一些列路径


看一个例子：


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

        String separator = File.separator;
        String filename = "test.txt";
        String directory = "testdir1"+separator+"testdir2";
        //String directory = "testdir1/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();
            }
        }
    }
}


这个例子里有一个小的注意事项，当找一个类的上层路径，如果这个类是属于某个package下的，那么上层路径应该是这个package的上层路径


//递归列出目录结构
public class Test {
    public static void main(String[] args){
        File f = new File("F:/java_workspace");
        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.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);
            }
        }
    }
}



五、枚举类


java.lang.Enum枚举类型


    

  • 只能够取特定值中的一个
    • 

  • 使用enum关键字
    • 

  • 是java.lang.Enum类型
    • 



枚举的意思其实就是事先定义一个范围，让程序在编译的时候就来检查你的变量、对象什么的是不是在这个范围内，而不是在执行的时候才发现


看个例子：


public class Test {

    public enum color {red, green, blue};

    public static void main(String[] args){
        color m = color.red;
        switch (m) {
            case red:
                System.out.println("red");
                break;
            case green:
                System.out.println("green");
                break;
            default:
                System.out.println("default: blue");
                break;
        }
    }
}
				


				
时间： 2024-07-29 00:15:12 

		


		


	

	
	

		


		
八、java常用类的相关文章


						

		

			

                java常用类之封装类
			

		

		

									

				public class BaseTypeClassTest { /*  *   常用类  *   1.基本类型的封装类:  在Java语言中,八种基本类型均对应着一个封装类.  *   *    byte ====>>>  Byte  *    short ===>>>  Short  *    int =====>>>  Integer  *    long ====>>>  Long  *   *    float ===>			

		

	

				

		

			

                Java基础 —— Java常用类
			

		

		

									

				Java常用类: java.lang包: java.lang.Object类: hashcode()方法:返回一段整型的哈希码,代表地址. toString()方法:返回父类名+"@"+哈希码(一般用于覆盖). equals()方法:返回"=="操作的布尔值(一般用于覆盖). finalize()方法:用于对象的销毁(不受人为控制,由JVM调用,遵从垃圾回收机制). clone()方法:用于对象之间的拷贝(深拷贝). getClass()方法:返回对象的字节码文件对			

		

	

				

		

			

                一大波Java来袭（三）Java常用类
			

		

		

									

				本文简单介绍集中Java常用类 不同种类的工具用于处理不同的工作.比如:厨房中的工具用于烹饪:农场中的工具用于养殖--对于Java的学习中处理不同的工作也要采用不同的工具.如:处理数学函数问题用Math类.针对文件的操作采用File类--这也充分体现了Java面向对象的特点 一.字符串类(重点理解内存模型) (一)String Java.lang.String字符串常量,具有不可变性. (二)StringBuffer Java.lang.StringBuffer字符串可变量,是线程安全的. (三			

		

	

				

		

			

                JAVA 常用类System以及Properties类的使用
			

		

		

									

				package ioTest.io1; import java.util.Iterator; import java.util.Properties; import java.util.Set; /* * System: * API描述:public final class System extends Object * System 类包含一些有用的类字段和方法.它不能被实例化. * 在 System 类提供的设施中,有标准输入.标准输出和错误输出流:对外部定义的属性和环境变量的访问: * 加			

		

	

				

		

			

                java常用类之String类
			

		

		

									

				public class StringTest{ /* * 1.字符串类: String . * 1) 什么是字符串? * 用一对双引号将一个或多个字符括起来组成的字符系列.例如: "A" "ABC" * 特殊的串: 一对连续的双引号.即: "" ,它称之为空串.也称之为长度为0的字符串. * * 2) 字符串的特性: * a) 字符串属于引用类型,一个字符串就是一个对象. * b) 字符串是不变的. * c) 字符串中每一个字符都有一个索引号(			

		

	

				

		

			

                Android逆向之Java常用类
			

		

		

									

				Android逆向之Java常用类 包装类 byte ­> Byte int ­> Integer short ­> Short long ­> Long float ­> Float double ­> Double boolean ­> Boolean char ­> Character   public static void test0(){        int n =123456;      // 整型转字符串         String nu			

		

	

						

		

			

                Java——常用类（String）
			

		

		

									

				[常用类] <1>字符串相关类(String.StringBuffer) <2>基本数据类型包装类 <3>Math类 <4>File类 <5>枚举类 [String类] <1>java.lang.String类代表不可变的字符序列. <2>String类的常见构造方法: String(String original) //创建一个String对象为original的拷贝 String(char[] value) //用一个			

		

	

				

		

			

                Java常用类集接口以及实现方式总结
			

		

		

									

				最近学习map-reduce原理以及map-reduce编程,于是顺带着学习下Java编程,对于Java常用的数据结构和类集,我总结到mind图中,便于理清相互之间的关系 package leiji; import java.util.ArrayList; import java.util.List; import java.util.Collection; public class ArryList { public static void main(String args[]){ List			

		

	

				

		

			

                java常用类-String
			

		

		

									

				Java String 类 字符串广泛应用 在Java 编程中,在 Java 中字符串属于对象,Java 提供了 String 类来创建和操作字符串. 创建字符串 创建字符串最简单的方式如下: 1 String greeting = "小猛"; 在代码中遇到字符串常量时,这里的值是 "小猛"",编译器会使用该值创建一个 String 对象. 和其它对象一样,可以使用关键字和构造方法来创建 String 对象. String 类有 11 种构造方法,这些方法