3.java常用类

最新推荐文章于 2022-11-02 09:21:48 发布

/*chen*/

最新推荐文章于 2022-11-02 09:21:48 发布

阅读量147

点赞数

分类专栏： java SE 文章标签： java

本文链接：https://blog.csdn.net/weixin_39722922/article/details/84201295

版权

java SE 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

0.数组

0.1概念、声明创建初始化索引

数组是相同类型数据的有序集合。相同类型可以是基本数据类型也可以是引用数据类型。

Demo：

public class Demo {
	public static void main(String[] args) {
		
		int[] a = {1,2,3,4,5}; //静态初始化
		
		String[] str = new String[3];
		str[0] = "ch";
		str[1] = "en";
		str[2] = "haha";  //动态初始化，也可以用循环
		
		Student[] stu = new Student[2];
		stu[0] = new Student("jack",18);
		stu[1] = new Student("mark",20);
		System.out.println(stu[1]);  //姓名mark年龄20
		int[][] b = {{1,2},{3,4,5},{6,7,8,9}};  //二维数组，每一维度可以长度不同，内存中存的是每个数组的地址
		
		
		System.out.println(str);  //直接输出的是地址，可以循环输出或者使用Arrays工具类
		//循环1
		for(int i=0;i<str.length;i++) {
			System.out.println(str[i]);
		}
		//循环2,只能用于输出
		for(String temp:str) {
			System.out.println(temp);
		}
		System.out.println(b[1][2]);  //5
		//二维数组两层循环即可
		for(int i=0;i<b.length;i++) {
			for(int j=0;j<b[i].length;j++) {
				System.out.println(b[i][j]);				
			}
		}
	} 
}

class Student{
	String name;
	int age;
	public Student(String name,int age) {
		this.name = name;
		this.age = age;
	}
	//重写Object类的toString方法
	public String toString() {
		return "姓名"+name+"年龄"+age;
	}
}

0.2数组常用工具类Arrays和System.copyof

System类中提供了数组的拷贝方法。

System.arraycopy(src, srcPos, dest, destPos, length);

java工具类中提供了便于操作数组的工具类Arrays

1.toString 将数组转化为字符串注意这里是不是Object的toString方法。

2.sort 将数组升序排序（快排）只提供了升序，降序的话先升序在倒着输出。

3.binarySearch(int[] a,int key) 二分法查找数组，返回元素索引值int类型

都是重载的基本支持各种类型

import java.util.Arrays;
//使用Arrays工具类需要导包。
public class test {
	public static void main(String[] args) {
 
		int arr[] = { 5, 4, 8, 9, 6, 7, 1, 2, 3 };
		// 遍历数组
		System.out.println(Arrays.toString(arr));// [5, 4, 8, 9, 6, 7, 1, 2, 3]
		// 数组升序排列
		Arrays.sort(arr);
		System.out.println(Arrays.toString(arr));
		// 查找4在当前数组中的位置，使用二分法查找
		System.out.println(Arrays.binarySearch(arr, 4));
 
	}
 
}

1.String类

1.1概念和注意事项

（1）字符串值为不可更改的常量，在创建字符串后便不能更改

（2）String类本身就重写了toString()方法，所以直接打印一个空的字符串对象是不会输出地址值而是什么都不输出

1.2String类常用方法

toCharArray() ：将字符串转化为字符数组。

getBytes()：将字符串转化为字节数组，通过ASCII码进行转化。

这些方法用到了去API找，找不到在自己写，常用的记住就行。

Demo：

import java.util.Arrays;

public class Demo {
	public static void main(String[] args) {
		String str1 ="hello world";
		String str2 = "HELLO WORLD";
		System.out.println(str1.charAt(2));  //第一个l
		System.out.println(str1.length());  //11
		System.out.println(str1.equals(str2));  //false
		System.out.println(str1.equalsIgnoreCase(str2));  //true
		System.out.println(str1.indexOf("wor"));  //6
		System.out.println(str1.substring(1,7));  //ello w 注意不包含7位置元素
		char[] ch = str1.toCharArray();
		System.out.println(Arrays.toString(ch)); //[h, e, l, l, o,  , w, o, r, l, d]
		byte[] by = str1.getBytes();  //编码
		System.out.println(Arrays.toString(by));//[104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100]
	
	} 
}

1.3StringBuilder和StringBuffer

特点：

（1）都是抽象类AbstractStringBuilder的子类，均为可变字符串序列，底层实现方式还是字节数组，只不过没有final修饰

（2）StringBuffer（字节缓冲区）和StringBuilder都是容器，可以操作不同数据类型。

（3）StringBuilder和StringBuffer对原字符串本身操作的，可以对字符串进行修改而不产生副本拷贝或者产生少量的副本。

在需要对字符串进行频繁操作时，效率高，占用内存低。（String类用完后由于是常量随着类结束释放，而数组扩容在不用后直接被垃圾回收）

（4）StringBuffer线程安全，做线程同步检查，效率低；

StringBuilder线程不安全，不做线程同步检查，效率高。（单线程优先采用）

常用方法：

1. 重载的public StringBuilder append(…)方法
可以为该StringBuilder 对象添加字符序列，仍然返回自身对象。
2. 方法 public StringBuilder delete(int start,int end)
可以删除从start开始到end-1为止的一段字符序列，仍然返回自身对象。
3. 方法 public StringBuilder deleteCharAt(int index)
移除此序列指定位置上的 char，仍然返回自身对象。
4. 重载的public StringBuilder insert(…)方法
可以为该StringBuilder 对象在指定位置插入字符序列，仍然返回自身对象。
5. 方法 public StringBuilder reverse()
用于将字符序列逆序，仍然返回自身对象。
6. 方法 public String toString() 返回此序列中数据的字符串表示形式。
7. 和 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() 
char charAt(int index)

Demo：

public class TestStringBufferAndBuilder 1{
    public static void main(String[] args) {
        /**StringBuilder*/
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 7; i++) {
            sb.append((char) ('a' + i));//追加单个字符
        }
        System.out.println(sb.toString());//转换成String输出  abcdefg
        sb.append(", I can sing my abc!");//追加字符串  
        System.out.println(sb.toString());  abcdefg，I can sing my abc!
        /**StringBuffer*/
        StringBuffer sb2 = new StringBuffer("中华人民共和国");
        sb2.insert(0, "爱").insert(0, "我");//插入字符串
        System.out.println(sb2);                 //我爱中华人民共和国
        sb2.delete(0, 2);//删除子字符串
        System.out.println(sb2);                //中华人民共和国
        sb2.deleteCharAt(0).deleteCharAt(0);//删除某个字符
        System.out.println(sb2.charAt(0));//获取某个字符  //人
        System.out.println(sb2.reverse());//字符串逆序    //国和共民人
    }
}

2.包装类

2.1概念

在实际应用中经常需要将基本数据转化成对象，以便于操作，比如将数据放入Object数组中，所以Java中每个基本类型都对应有一个包装类型。

除了int--Integer和char--Character型之外其他基本类型的包装类型都是类型的首字母大写。

2.2使用

1. 作为和基本数据类型对应的类型存在，方便涉及到对象的操作，最常用的是基本数据类型和字符串的相互转换。

基本数据类型转为字符串：

基本数据类型+""
包装类.toString（基本数据类型值） Integer.toString（34）//整数34转化为字符串"34"

字符串转为基本数据类型：

xxx a = Xxx.parseXxx(String) int a = Integer.parseInt("123") //将字符串123转为数字123

2. 包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法(这些操作方法的作用是在基本数据类型、包装类对象、字符串之间提供相互之间的转化!)

2.3自动装箱与拆箱

public class Demo {
	public static void main(String[] args) {
		
		Integer a = new Integer(4);//手动装箱
                Integer b = Integer.valueOf(4);//手动装箱 官方推荐这种写法
		int c = a.valueOf(a); //手动拆箱
		//JDK1.5后提供了自动装箱和拆箱
		Integer x = 4;  //自动装箱
		x = x + 4;    //先自动拆箱x.valueOf(x)+4，后自动装箱
	} 
}

最后注意下：整型、char类型所对应的包装类，在自动装箱时，对于-128~127之间的值会进行缓存处理，如果数据在-128~127这个区间，那么在类加载时就已经为该区间的每个数值创建了对象，并将这256个对象存放到一个名为cache的数组中。每当自动装箱过程发生时(或者手动调用valueOf()时)，就会先判断数据是否在该区间，如果在则直接获取数组中对应的包装类对象的引用，如果不在该区间，则会通过new调用包装类的构造方法来创建对象。所以注意判断两个Integer对象是否相同时注意。

3.时间相关类（Date、DateFormat、Calendar）

3.0获得系统当前时间

long start = System.currentTimeMillis(); //获取系统当前时间，常用来看程序运行时间

3.1Date类

构造方法
Date()
初始化一个Date对象，测量一个当前最近的毫秒值。数值是从1970年1月1日00:00:00到当前系统时间的毫秒值。，存在一定时差跟底层操作系统有关。

Date(long date)
指定一个毫秒值创建Date对象，这里指定的是从1970年1月1日00:00:00起到指定时间所经历的毫秒值。

常用方法

setTime(long time) 为当前Date对象设置毫秒值

getTime() 返回Date对象的毫秒值转换成long类型返回。

demo：

import java.util.Date;//使用Date类需要导包，注意是util包下的Date不是sql包下的。
 
public class Datetest {
	public static void main(String[] args) {
		Date d = new Date();// 创建Date类对象
		// 直接打印输出的是Date的日期格式
		System.out.println(d);// Thu May 03 20:13:36 CST 2018
		// 使用指定的毫秒值创建Date对象
		Date d2 = new Date(1000);
		// 这里因为是基于底层操作系统的时间计算的所以存在时差，当前操作系统是从1970年1月1日8：00开始计算时间的
		System.out.println(d2);// Thu Jan 01 08:00:01 CST 1970
		d.setTime(1000);// 为Date对象设置时间
		System.out.println(d);// Thu Jan 01 08:00:01 CST 1970
		Date d3 = new Date();
		long i = d3.getTime();// 将Date对象传换成毫秒值。
		System.out.println(i);// 1525349616789
 
	}
}

3.2SimpleDateFormat类

把时间对象转化成指定格式的字符串。反之，把指定格式的字符串转化成时间对象。

DateFormat是一个抽象类，一般使用它的的子类SimpleDateFormat类来实现。

常用构造方法 SimpleDateFormat(String pattern)

使用规定的格式来创建一个SimpleDateFormat类对象。一般为yyyy-MM-dd hh:mm:ss 表示年-月-日时:分:秒。

常用方法
format(Date date) 使用SimpleDateFormat对象将Date类对象转化成String类型，括号中的参数需要给定一个Date类对象。

parse(String source)通过SimpleDateFormat对象将指定字符串通过SimpleDateFormat中指定的格式解析成Date类对象的日期格式。需要注意如果给定的字符串格式不符合SimpleDateFormat中规定的格式将会发生异常ParseException。

Demo：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo {
	public static void main(String[] args) throws ParseException {
		
		//Date转String（格式化）
		Date d = new Date(); //获得当前时间
		System.out.println(d);  //Tue Nov 20 20:33:44 CST 2018
		// 创建SimpleDateFormat对象，并规定格式化格式。
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
		String s = sdf.format(d); //format方法将Date对象转化成String类型
		System.out.println(s);  //2018年11月20日 20时31分07秒
		
		//String转Date（解析）
		String str = "1970-1-2 0:0:0";
		SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date d2 = new Date();
		d2 = sdf2.parse(str);
		System.out.println(d2);  //Fri Jan 02 00:00:00 CST 1970
	} 
}

具体参数查api即可

3.3Calendar类

Calendar 类是一个抽象类，为我们提供了关于日期计算的相关功能，比如：年、月、日、时、分、秒的展示和计算。

GregorianCalendar 是 Calendar 的一个具体子类，提供了世界上大多数国家/地区使用的标准日历系统。

import java.util.*;
public class TestCalendar {
    public static void main(String[] args) {
        // 得到相关日期元素
        GregorianCalendar calendar = new GregorianCalendar(2999, 10, 9, 22, 10, 50);
        int year = calendar.get(Calendar.YEAR); // 打印：1999
        int month = calendar.get(Calendar.MONTH); // 打印：10
        int day = calendar.get(Calendar.DAY_OF_MONTH); // 打印：9
        int day2 = calendar.get(Calendar.DATE); // 打印：9
        // 日：Calendar.DATE和Calendar.DAY_OF_MONTH同义
        int date = calendar.get(Calendar.DAY_OF_WEEK); // 打印：3
        // 星期几 这里是：1-7.周日是1，周一是2，。。。周六是7
        System.out.println(year);
        System.out.println(month);
        System.out.println(day);
        System.out.println(day2);
        System.out.println(date);
        // 设置日期
        GregorianCalendar calendar2 = new GregorianCalendar();
        calendar2.set(Calendar.YEAR, 2999);
        calendar2.set(Calendar.MONTH, Calendar.FEBRUARY); // 月份数：0-11
        calendar2.set(Calendar.DATE, 3);
        calendar2.set(Calendar.HOUR_OF_DAY, 10);
        calendar2.set(Calendar.MINUTE, 20);
        calendar2.set(Calendar.SECOND, 23);
        printCalendar(calendar2);
        // 日期计算
        GregorianCalendar calendar3 = new GregorianCalendar(2999, 10, 9, 22, 10, 50);
        calendar3.add(Calendar.MONTH, -7); // 月份减7
        calendar3.add(Calendar.DATE, 7); // 增加7天
        printCalendar(calendar3);
        // 日历对象和时间对象转化
        Date d = calendar3.getTime();
        GregorianCalendar calendar4 = new GregorianCalendar();
        calendar4.setTime(new Date());
        long g = System.currentTimeMillis();
    }
    static void printCalendar(Calendar calendar) {
        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH) + 1;
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        int date = calendar.get(Calendar.DAY_OF_WEEK) - 1; // 星期几
        String week = "" + ((date == 0) ? "日" : date);
        int hour = calendar.get(Calendar.HOUR);
        int minute = calendar.get(Calendar.MINUTE);
        int second = calendar.get(Calendar.SECOND);
        System.out.printf("%d年%d月%d日,星期%s %d:%d:%d\n", year, month, day,  
                        week, hour, minute, second);
    }
}

4.Math类

java.lang.Math包含执行基本数字运算的方法，如基本指数，对数，平方根和三角函数。基本上学过的一些基本运算都包含。

计算高等数学中的相关内容，可以使用apache commons下面的Math类库。

常用方法：

1. abs 绝对值
2. acos,asin,atan,cos,sin,tan 三角函数
3. sqrt 平方根
4. pow(double a, double b) a的b次幂
5. max(double a, double b) 取大值
6. min(double a, double b) 取小值
7. ceil(double a) 大于a的最小整数
8. floor(double a) 小于a的最大整数
9. random() 返回 0.0 到 1.0 的随机数
10. long round(double a) double型的数据a转换为long型(四舍五入)
11. toDegrees(double angrad) 弧度->角度
12. toRadians(double angdeg) 角度->弧度

Demo：

public class TestMath {
    public static void main(String[] args) {
        //取整相关操作
        System.out.println(Math.ceil(3.2));
        System.out.println(Math.floor(3.2));
        System.out.println(Math.round(3.2));
        System.out.println(Math.round(3.8));
        //绝对值、开方、a的b次幂等操作
        System.out.println(Math.abs(-45));
        System.out.println(Math.sqrt(64));
        System.out.println(Math.pow(5, 2));
        System.out.println(Math.pow(2, 5));
        //Math类中常用的常量
        System.out.println(Math.PI);
        System.out.println(Math.E);
        //随机数
        System.out.println(Math.random());// [0,1)
    }
}

结果

注意下Math.random()方法。

public class Demo {
	public static void main(String[] args) {
		double d = Math.random();  //产生0~1之间的随机数，返回double类型
		System.out.println(d); 
		System.out.println(5+3*(Math.random()));  //返回5~8之间的随机数
	} 
}

5.Random类

java.util.Random用来获取伪随机数的类

构造方法

Random() 创建一个新的随机数对象。

Random(long seed) 使用一个种子数创建一个新的随机数对象。这个种子数对最终生成的随机数没有直接的影响。

常用方法

nextInt() 获取一个随机数,它的范围是在int类型范围之内。

nextInt(int n) 获取随机数,它的范围是在0到n之间，不包含n。

Demo：

import java.util.Random;
 
public class RandomDemo {
	public static void main(String[] args) {
		// 创建Random类对象
		Random r = new Random();
		for (int x = 0; x < 5; x++) {
			System.out.print(r.nextInt() + "  ");
		}
		// 830935364 -985538965 -619964702 -646748403 338999265
		System.out.println();
		for (int x = 0; x < 5; x++) {
			System.out.print(r.nextInt(10) + "  ");
		}
		// 2 6 5 6 0
	}
}

6.File类

构造方法：

File(String pathname)
File(String parent, String child)
File(File parent, String child)

常用方法：

1.访问文件属性

è¡¨8-3 Fileç±»è®¿é®å±æ§çæ¹æ³åè¡¨.png

demo：

import java.io.File;
import java.util.Date;

/**
 * 测试File类常用方法
 * @author chen
 *
 */
public class TestFile {
	public static void main(String[] args) {
		File f = new File("abc.jpg");  //相对路径
		
		System.out.println("File是否存在："+f.exists());
	    System.out.println("File是否是目录："+f.isDirectory());
	    System.out.println("File是否是文件："+f.isFile());
	    System.out.println("File最后修改时间："+new Date(f.lastModified()));
	    System.out.println("File的大小："+f.length());
	    System.out.println("File的文件名："+f.getName());
	    System.out.println("File的目录路径："+f.getPath());
	}
}

2.创建空文件或目录

è¡¨8-4 Fileç±»åå»ºæä»¶æç®å½çæ¹æ³åè¡¨.png

demo：注意mkdir和mkdirs的区别

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

/**
 * 测试File类常用方法
 * @author chen
 *
 */
public class TestFile {
	public static void main(String[] args) throws IOException {
		File f = new File("d:/c.txt");  //绝对路径
		
		f.createNewFile(); // 会在d盘下面生成c.txt文件
        f.delete(); // 将该文件或目录从硬盘上删除
        
        File f2 = new File("d:/电影/华语/大陆");
        boolean flag = f2.mkdir(); //目录结构中有一个不存在，则不会创建整个目录树
        System.out.println(flag);//创建失败
        
        boolean flag2 = f2.mkdirs();//目录结构中有一个不存在也没关系；创建整个目录树
        System.out.println(flag2);//创建成功
	}
}

使用递归打印文件夹下的所有内容

import java.io.File;

public class TestFile {
	public static void main(String[] args) {
		File f = new File("D:/测试文件夹");
		printFile(f,0);
	}
	//递归打印
	public static void printFile(File file,int level) {
		//输出层次数
        for (int i = 0; i < level; i++) {
            System.out.print("-");
        }
		System.out.println(file.getName());
		if(file.isDirectory()) {
			File[] files = file.listFiles();
			for(File temp:files) {
				printFile(temp,level+1);
			}
		}
	}
}

/*chen*/

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
3.java常用类

0.数组0.1概念、声明创建初始化索引数组是相同类型数据的有序集合。相同类型可以是基本数据类型也可以是引用数据类型。Demo：public class Demo { public static void main(String[] args) { int[] a = {1,2,3,4,5}; //静态初始化 String[] str = new String...
复制链接

扫一扫

专栏目录