Java中的常用类

Java 中，有许多常用的类被广泛用于各种应用程序开发中。也是 Java 编程中不可或缺的部分，它们提供了编程过程中需要的基础功能。

1、Java中基本类型的包装类

   Java中的基本类型我们应该都知道，例如，int、float、double、boolean、char 等。为了让基本类型也具有对象特性，Java为每个基本数据类型都提供了一个包装类，这样就可以像操作对象那样操作基本数据类型。

基本类型对应的包装类
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
charCharacter
booleanBoolean

包装类其实就是提供类型转换的方法。以Integer为例看一下。

Integer包装类的构造方法：
Integer(int value)：创建一个Integer对象，表示指定的int值。  
Integer(String s) ：创建一个Integer对象，表示String参数所指示的int值。

如下代码所示：

        Integer a=new Integer(4);//定义包装类对象
        Integer b=new Integer("11");//定义包装类对象

Integer包装类的常用方法：

方法描述
byteValue()将该Integer转为byte类型。
// Integer obj=new Integer(1);
// byte b=obj.byteValue();
doubleValue()将该Integer转为double类型。
// Integer obj=new Integer(1);
// double d=obj.doubleValue();
floatValue()将该Integer转为float类型。
// Integer obj=new Integer(1);
// float f=obj.floatValue();
intValue()将该Integer转为int类型。
// Integer obj=new Integer(1);
// int i=obj.intValue();
longValue()将该Integer转为long类型。
// Integer obj=new Integer(1);
//  long l=obj.longValue();
parseInt(String s)将字符串转为int类型。
// int i = Integer.parseInt("30");
toString()将该Integer转换成字符串。
// Integer obj=new Integer(1);
// String s=obj.toString();
valueOf(String s)将字符串转为Integer类型。
// int i = Integer.valueOf("30");

2、Date和SimpleDateFormat类

我处理日期和时间相关的数据，我们可以使用java.util包中的Date类。Date类主要的作用是获取当前时间。而java.text包中的SimpleDateFormat类主要是对日期时间进行格式化的。具体如下，

import java.text.SimpleDateFormat;
import java.util.Date;
public class DateFormat {
public static void main(String []args){
        //创建Date对象，表示当前时间
        Date d=new Date();
        //创建SimpleDateFormat对象，指定目标格式
        // “yyyy-MM-dd HH:mm:ss” 为预定义字符串， yyyy 表示四位年， MM 表示两位月份， dd 表示两位日期，                                    HH 表示小时(使用24小时制)， mm 表示分钟， ss 表示秒
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //调用format()方法，格式化时间，转换为指定格式字符串
        String today=sdf.format(d);
        //输出转换后的字符串
        System.out.println(today);//运行结果：2018-07-29 21:51:50
    }
}

使用parse()方法将日期格式字符串转成Date对象。

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateFormat {
    public static void main(String []args){
            //创建SimpleDateFormat对象，指定字符串的日期格式
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String day="2016-12-30 14:52:30";  //创建日期格式的字符串
             
            try {
                //调用parse()方法，将字符串转换为日期
                Date date =(Date)df.parse(day);
                //输出转换后的时间
                System.out.println("当前时间；" + date);
            } catch (ParseException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }  
    }
}

3、Calendar类

  从JDK1.1版本开始，在处理日期和时间时，系统推荐使用Calendar类进行实现(Date的一些方法都过时了)。在设计上，Calendar类的功能要比Date类强大很多。

import java.util.Calendar;
 
public class  CalendarDemo{
    public static void main(String []args){
        //创建Calendar对象
        Calendar c=Calendar.getInstance();
        //获取年
        int year=c.get(Calendar.YEAR);
        //获取月份，0表示1月份
        int month=c.get(Calendar.MONTH)+1;
        //获取日期
        int day=c.get(Calendar.DAY_OF_MONTH);
        //获取小时
        int hours=c.get(Calendar.HOUR_OF_DAY);
        //获取分钟
        int minute=c.get(Calendar.MINUTE);
        //获取秒
        int scond=c.get(Calendar.SECOND);
        //输出结果
        System.out.println(year+"-"+month+"-"+day+" "+hours+":"+minute+":"+scond);
        //运行结果是：2018-07-29 22:56:9
         
    }
}

Calendar 类提供了 getTime() 方法，用来获取 Date 对象，完成 Calendar 和 Date 的转换，还可通过 getTimeInMillis() 方法，获取此 Calendar 的时间值，以毫秒为单位。如下所示：

import java.util.Calendar;
import java.util.Date;
 
public class CalendarDemo {
    public static void main(String []args){
        //创建Calendar对象
        Calendar c=Calendar.getInstance();
        //将Calendar对象转换为Date对象
        Date date=c.getTime();
        //获取当前毫秒数
        Long time=c.getTimeInMillis();
        System.out.println("当前时间："+date);
        System.out.println("毫秒数："+time);       
        //运行结果为： （系统当前时间）
        //当前时间：Sun Jul 29 23:03:56 CST 2018
        //毫秒数：1532876636921
    }  
}

4、Math类

Math 类位于 java.lang 包中，包含用于执行基本数学运算的方法， Math 类的所有方法都是静态方法，所以使用该类中的方法时，可以直接使用类来调用。例如，

Math.random();
public class MathDemo {
    public static void main(String []args){
        //定义一个double类型的变量
        double a=12.08;
        //将double类型强制转换 int类型，去掉小数位
        int b=(int) a;
        System.out.println("强制转换为："+b);
        //调用round方法，进四舍五入
        Long c=Math.round(a);
        System.out.println("返回四舍五入的整数："+c);
        //调用floor方法，小于参数的最大
        double d=Math.floor(a);
        System.out.println("返回小于参数的最大整数："+d);
        //调用ceil方法，大于参数的最小
        double e=Math.ceil(a);
        System.out.println("返回大于参数的最小整数："+e);
        //调用random方法，随机数[0，1）之间的 随机浮点数
        double f=Math.random();
        System.out.println("随机数："+f);
        //调用random方法，随机[0，99）之间的整数
        int g=(int)(Math.random()*99);
        System.out.println("返回[0，99）之间的随机整数："+g);
    }  
}

5、Random类

下面Random()的两种构造方法：
　　　　 Random()：创建一个新的随机数生成器。
　　　　 Random(long seed)：使用单个 long 种子创建一个新的随机数生成器。
我们可以在构造Random对象的时候指定种子（这里指定种子有何作用，请接着往下看），如：Random r1 = new Random(20);
或者默认当前系统时间的毫秒数作为种子数:Random r1 = new Random();
需要说明的是：你在创建一个Random对象的时候可以给定任意一个合法的种子数，种子数只是随机算法的起源数字，和生成的随机数的区间没有任何关系。如下面的Java代码：

Random rand =new Random(25);
int i;
i=rand.nextInt(100);//得到一个随机数

6、String 类

用于处理文本数据。它提供了多种方法来操作字符串，如长度计算、字符串连接、子字符串、替换等。Java 中的 String 类是用于操作字符串的非常常用的类。它是不可变的，创建了 String 对象，就不能更改这个对象中的字符串。在涉及频繁修改字符串的场景中，考虑使用 StringBuilder 或 StringBuffer 以提高性能。在进行字符串比较时，equals() 方法比 == 运算符更为可靠，因为 == 比较的是对象的引用而不是内容。String 类在 Java 中非常常用，熟练掌握其方法和特性对于进行有效的字符串操作至关重要。

public class Main {
  public static void main(String[] args) {
       // 创建字符串
        String str1 = "Hello World";
        String str2 = new String("Welcome to Java");

        // 字符串长度
        System.out.println("Length of str1: " + str1.length());

        // 字符串连接
        String str3 = str1.concat(" - ").concat(str2);
        System.out.println("Concatenated String: " + str3);

        // 字符串比较
        System.out.println("str1 equals str2? " + str1.equals(str2));

        // 字符串查找
        System.out.println("Index of 'World' in str1: " + str1.indexOf("World"));

        // 字符串截取
        System.out.println("Substring of str1 from index 6: " + str1.substring(6));

        // 字符串替换
        System.out.println("Replace 'Hello' with 'Hi' in str1: " + str1.replace("Hello", "Hi"));

        // 字符串转换
        System.out.println("Uppercase of str1: " + str1.toUpperCase());

        // 字符串去空格
        String str4 = "  Hello Java  ";
        System.out.println("Trimmed str4: '" + str4.trim() + "'");

        // 字符串分割
        String[] parts = str1.split(" ");
        System.out.println("Split str1: " + java.util.Arrays.toString(parts));

        // 字符串格式化
        String formattedStr = String.format("Name: %s, Age: %d", "Alice", 30);
        System.out.println("Formatted String: " + formattedStr);

        // 转换为字符数组
        char[] charArray = str1.toCharArray();
        System.out.print("Characters in str1: ");
        for (char c : charArray) {
            System.out.print(c + " ");
        }
        System.out.println();

        // 获取特定索引的字符
        System.out.println("Character at index 0 in str1: " + str1.charAt(0));

        // 字符串是否为空
        System.out.println("Is str1 empty? " + str1.isEmpty());

        // 字符串转换为基本数据类型
        String numberStr = "100";
        int number = Integer.parseInt(numberStr);
        System.out.println("Integer value of numberStr: " + number);
  }
}

7、Object 类

Java 中的 Object 类是所有类的超类（父类），所有的 Java 类都继承自 Object 类。Object 类提供了一些基本方法，这些方法对所有 Java 对象都有效。在重写 equals 方法时，通常也需要重写 hashCode 方法，以保持两者之间的一致性。toString 方法通常用于提供对象的有用信息，特别是在调试时。

public class Main {
  public static void main(String[] args) {
      // 创建 Person 对象
        Person person1 = new Person("John Doe", 30);
        Person person2 = new Person("Jane Doe", 25);
        Person person3 = new Person("John Doe", 30);

        // 使用 toString 方法打印对象信息
        System.out.println("Person1: " + person1.toString());
        System.out.println("Person2: " + person2);

        // 比较对象是否相等
        System.out.println("Person1 equals Person2: " + person1.equals(person2));
        System.out.println("Person1 equals Person3: " + person1.equals(person3));

        // 获取对象的哈希码
        System.out.println("HashCode of Person1: " + person1.hashCode());
        System.out.println("HashCode of Person2: " + person2.hashCode());
        System.out.println("HashCode of Person3: " + person3.hashCode());

        // 使用 getClass 方法
        System.out.println("Class of Person1: " + person1.getClass().getName());
  }
  
}
class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 重写 toString 方法
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    // 重写 equals 方法
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && name.equals(person.name);
    }

    // 重写 hashCode 方法
    @Override
    public int hashCode() {
        return name.hashCode();
    }
}

8、System 类

Java 的 System 类提供了一系列用于系统级操作和系统属性访问的静态方法和变量。使用 System.out 和 System.err 输出信息时，System.err 通常用于打印错误或诊断信息。系统属性和环境变量可用于获取关于系统配置的信息。

public class Main {
  public static void main(String[] args) {
          // 标准输出
        System.out.println("Hello, World!");

        // 标准错误输出
        //System.err.println("Error Message");

        // 获取系统属性
        String javaVersion = System.getProperty("java.version");
        String osName = System.getProperty("os.name");
        System.out.println("Java Version: " + javaVersion);
        System.out.println("Operating System: " + osName);

        // 设置和获取自定义系统属性
        System.setProperty("myProperty", "myValue");
        String myProperty = System.getProperty("myProperty");
        System.out.println("Custom Property: " + myProperty);

        // 获取环境变量
        String path = System.getenv("PATH");
        System.out.println("Path: " + path);

        // 时间测量（毫秒）
        long startTime = System.currentTimeMillis();
        // 模拟一些操作
        try {
            Thread.sleep(1000); // 休眠 1 秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("Time taken: " + (endTime - startTime) + " ms");

        // 时间测量（纳秒）
        long startNanoTime = System.nanoTime();
        // 模拟一些操作
        for (int i = 0; i < 1000; i++) {
            // 空循环
        }
        long endNanoTime = System.nanoTime();
        System.out.println("Time taken: " + (endNanoTime - startNanoTime) + " ns");

        // 垃圾回收
        System.gc();
        // System.exit(0); // 正常退出程序

  }
}

9、Arrays 类

Java 的 Arrays 类是 java.util 包的一部分，提供了一系列静态方法来操作数组，比如排序、搜索、比较和填充等。

import java.util.Arrays;

public class Main {
  public static void main(String[] args) {
       // 排序
        int[] arr = {5, 3, 7, 1, 4};
        Arrays.sort(arr);
        System.out.println("Sorted array: " + Arrays.toString(arr));

        // 搜索（使用二分法）
        int index = Arrays.binarySearch(arr, 5);
        System.out.println("Index of 5: " + index);

        // 比较数组
        int[] arr1 = {1, 2, 3};
        int[] arr2 = {1, 2, 3};
        int[] arr3 = {1, 2, 4};
        System.out.println("arr1 equals arr2? " + Arrays.equals(arr1, arr2));
        System.out.println("arr1 equals arr3? " + Arrays.equals(arr1, arr3));
        // 填充数组
       int[] fillArr = new int[5];
       Arrays.fill(fillArr, 10);
       System.out.println("Filled array: " + Arrays.toString(fillArr));
   
       // 数组转列表
       String[] strArr = {"apple", "banana", "cherry"};
       java.util.List<String> list = Arrays.asList(strArr);
       System.out.println("List: " + list);
   
       // 复制数组
       int[] copied = Arrays.copyOf(arr1, 3);
       System.out.println("Copied array: " + Arrays.toString(copied));
   
       // 数组转字符串
       String arrString = Arrays.toString(arr);
       System.out.println("Array as String: " + arrString);
   
       // 数组的哈希码
       int arrHashCode = Arrays.hashCode(arr);
       System.out.println("Hash code of array: " + arrHashCode);

  }
}

10、ArrayList 类

Java 中的 ArrayList 类是 java.util 包的一部分，提供了动态数组的功能。与普通数组相比，ArrayList 的大小可以动态变化。它提供了添加、搜索、更新和删除元素的方法。ArrayList 是基于数组实现的，提供了随机访问的能力。ArrayList 不是线程安全的。如果多线程环境中需要使用动态数组，可以考虑使用 Vector 或 Collections.synchronizedList 方法同步 ArrayList。

import java.util.*;

public class Main {
  public static void main(String[] args) {
// 创建一个空的 ArrayList
        ArrayList<String> fruits = new ArrayList<>();

        // 添加元素
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");

        // 获取特定索引的元素
        String firstFruit = fruits.get(0);
        System.out.println("First fruit: " + firstFruit);

        // 修改指定索引位置的元素
        fruits.set(1, "Blueberry");
        System.out.println("Modified fruits list: " + fruits);

        // 删除特定索引的元素
        fruits.remove(2);
        System.out.println("After removing an element: " + fruits);

        // 删除特定元素
        fruits.remove("Apple");
        System.out.println("After removing 'Apple': " + fruits);

        // 使用 for-each 循环遍历 ArrayList
        System.out.println("Remaining fruits:");
        for (String fruit : fruits) {
            System.out.println(fruit);
        }

        // 获取 ArrayList 的大小（元素个数）
        int size = fruits.size();
        System.out.println("Number of fruits: " + size);

        // 检查 ArrayList 是否为空
        boolean isEmpty = fruits.isEmpty();
        System.out.println("Is the fruits list empty? " + isEmpty);

        // 清空 ArrayList
        fruits.clear();
        System.out.println("After clearing the fruits list: " + fruits);

        // 将 ArrayList 转换为普通数组
        fruits.addAll(Arrays.asList("Mango", "Strawberry", "Pineapple"));
        String[] fruitsArray = fruits.toArray(new String[0]);
        System.out.println("Array: " + Arrays.toString(fruitsArray));

        // 检查 ArrayList 是否包含特定元素
        boolean containsMango = fruits.contains("Mango");
        System.out.println("Contains Mango: "+ containsMango);

  }
}

11、StringBuilder 和 StringBuffer 类

StringBuilder 和 StringBuffer 类用于创建可修改的字符串。StringBuilder 是非线程安全的，而 StringBuffer 是线程安全的。

import java.util.*;

public class Main {
  public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello");

        // 添加字符串
        sb.append(" World");

        // 插入字符串
        sb.insert(5, ",");

        // 替换字符串
        sb.replace(6, 11, "Java");

        // 删除字符串
        sb.delete(5, 6);

        // 反转字符串
        sb.reverse();

        // 将 StringBuilder 转换为 String
        String result1 = sb.toString();

        System.out.println(result1);
        
        StringBuffer sbf = new StringBuffer("Hello");

        // 添加字符串
        sbf.append(" World");

        // 插入字符串
        sbf.insert(5, ",");

        // 替换字符串
        sbf.replace(6, 11, "Java");

        // 删除字符串
        sbf.delete(5, 6);

        // 反转字符串
        sbf.reverse();

        // 将 StringBuffer 转换为 String
        String result2 = sb.toString();

        System.out.println(result2);


  }
}

12、File 类

Java 中的 File 类是 java.io 包的一部分，用于表示文件和目录路径名的抽象表示形式。用于创建、修改、删除文件和目录。

import java.io.File;
import java.io.IOException;

public class Main {
  public static void main(String[] args) {
         // 创建 File 对象
        File file = new File("example.txt");

        // 检查文件是否存在
        boolean exists = file.exists();
        System.out.println("File exists: " + exists);

        // 获取文件信息
        if (exists) {
            System.out.println("File name: " + file.getName());
            System.out.println("Absolute path: " + file.getAbsolutePath());
            System.out.println("Size: " + file.length() + " bytes");
            System.out.println("Readable: " + file.canRead());
            System.out.println("Writable: " + file.canWrite());
            System.out.println("Executable: " + file.canExecute());
        } else {
            // 创建新文件
            try {
                boolean created = file.createNewFile();
                System.out.println("File created: " + created);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        // 重命名文件
        File newFile = new File("newExample.txt");
        boolean renamed = file.renameTo(newFile);
        System.out.println("File renamed: " + renamed);

        // 创建目录
        File directory = new File("exampleDir");
        boolean dirCreated = directory.mkdir();
        System.out.println("Directory created: " + dirCreated);

        // 列出目录文件
        File[] files = directory.listFiles();
        if (files != null) {
            for (File f : files) {
                System.out.println(f.getName());
            }
        }

        // 删除文件
        boolean deleted = newFile.delete();
        System.out.println("File deleted: " + deleted);

        // 删除目录
        boolean dirDeleted = directory.delete();
        System.out.println("Directory deleted: " + dirDeleted);

  }
}

推荐阅读
cjavapy编程之路首页
版权所有 © 2018 cjavapy.com 保留所有权利
吉ICP备18005501号-1