常用API StringBuffer，StringBuilder_stringbuffer substring下标开始位置

String

java.lang.String是字符串类

1它的底层就是一个子字符数组，所以它的许多特性就是数组的特性

2字符串需要使用" "表示

3 为了提高字符串访问效率，提出了一个缓存机制，字符串常量池

 

基本使用

package day_7_13API;
/**
 * 
 * java.lang.String是字符串类
 *
 *1它的底层就是一个子字符数组，所以它的许多特性就是数组的特性
 *
 *2字符串需要使用" "表示
 *
 *3 为了提高字符串访问效率，提出了一个缓存机制，字符串常量池
 * 
 * @author 啊超
 * @Date 2021年7月13日
 */
public class txt {
	public static void main(String[] args){
	//尽管没有new，但是s1依然代表String的对象，因为字符串常量池
	String s1="abc";
	//s1没有使用finall修饰，所以s1的值可以更改，只不过是让s1指向了bcd这个字符串对象，而abc这个对象没有更改
	s1="bcd";
	//第二部分
	String s2="Hello";
	String s3="Hello";
	String s4="hello";
	//s2和s3都指向常量池中的这个字符串对象，所以内存地址都相同
	System.out.println(s2==s3);
	//s4指向常量池中新的字符串对象，因为h和H是不一样的。
	System.out.println(s4==s3);
	System.out.println(s2.equals(s3));
	//第三种
	String s5=new String("abc");
	String s6=new String("abc");
	String s7="abc";
	//s5和s6是new的方式，所以分别指向各自的堆内存，这样用==肯定是 false
	System.out.println(s5==s6);   //false
	System.out.println(s5==s7);  //false
	//但是String类中覆写了equals方法，比较的是值，而不是内存地址
	//所以我们比较字符串是否相等的时候，应该使用rquals ，而不是==
	System.out.println(s5.equals(s6));  //true
	
	
	}
}

不要频繁拼接

package day_7_13API;
/**
 * 因为String 一旦创建，字符串对象不可更改
 * 
 * 尽量不要使用String进行大量的字符串拼接操作
 * 
 * @author 啊超
 * @Date 2021年7月13日
 */
public class String_02 {
	public static void main(String[] args){
		String[] arr={"a","b","c"};
		String temp ="";
		for(int i=0;i<arr.length;i++){
			//ab
			//abc
			temp+=arr[i];
			
		}
		System.out.println(temp);
		
	}
 
}

构造方法

 

package day_7_13API;
/**
 * 
 * 构造方法
 * 
 * @author 啊超
 * @Date 2021年7月13日
 */
public class String_3 {
	public static void main(String [] args){
		//1字面量
		String s1="abc";
		//s2
		String s2=new String("xxx");
		//3字节数组
		byte [] bytes={97,98,99,100,101,102};
		String s3=new String(bytes);
		//abcdef
		System.out.println(s3);
		//4截取字节数组一部分
		//下标为3开始的（包括3）取两个
		String s4=new String (bytes,3,2);
		System.out.println(s4);   // de
		//5 字符数组
		char [] chars={'a','b','c','d','e'};
		String s5=new String (chars);
		System.out.println(s5);
		//6截取字符数组的一部分
		//下标2开始（包含）取两个
		String  s6=new String(chars,2,2);
		System.out.println(s6);  //cd
		
		
			
	}
 
}

常用方法

package day_7_13API;
/**
 * 
 * 常用方法
 * 
 * @author 啊超
 * @Date 2021年7月13日
 */
public class String_4 {
	public static void main(String[] args){
		String s1="querw";
		//1 char charAt(int  index); 获取字符串中某个位置上的字符
		System.out.println(s1.charAt(2)); //e
		
		//2 boolean startsWith(String prefix);是否以指定字符串开始
		System.out.println("Hello ,world".startsWith("He")); //true
		//是否以指定字符串结尾
		System.out.println("Hello.java".endsWith("java")); //true
		//要注意空格，空格也算是字符串的
		
		//3 boolean equals(Object obj);比较两个字符串是否相等
		System.out.println("abc".equals("Abc")); //false
		//可以不区分大小写比较
		System.out.println("abc".equalsIgnoreCase("Abc")); //true
		
		System.out.println(1111); //划分
		
		//4byte[] getBytes();把字符串转换为  字节数组
		byte []bytes="abc".getBytes();
		for(byte b:bytes){
			System.out.println(b); //97,98,99
		}
		//5 char[] toCharArray();把字符串转为  字符数组
		char [] chars="abc".toCharArray();
		for( char c: chars){
			System.out.println(c);//a,b,c
		}
		//字节数组转换字符串； new String(bytes,起始值，个数);
		//字符串转字节数组  getBytes();
		//字符数组转字符串  new String(chars,起始值，个数);
		//字符串转字符数组  toCharArray();
		// 6 int indexOf(String str);获取字符串中，指定字符串的起始索引，找不到就返回-1
		System. out.println("abcdefghigklmn".indexOf("bc"));  //1,这个1是找到的索引
		
		// 7 int  lastIndexOf(String str);获取字符串中，指定字符串最后一次出现的索引，找不到返回-1
		System.out.println("abcdersfafaw".lastIndexOf("fa")); //9
		//8 int length();返回字符串的长度
		System.out.println("abc".length()); //3
		//9 String replaceAll(String regex,String replacement); 把指定字符串，用某个字符串代替
		//replace; 这个方法和replaceAll 几乎是一样的，只是replaceAll支持正则表达式，而replace不支持正则表达式
		//例如 1111 因为，在正则表达式中，可以匹配任意字符，所以把所有字符都替换为1
		System.out.println("abc.d.ate".replaceAll(".","1"));  // 111111111 9个1  这里.是所有的符号
		//abuub,就是不识别正则表达式
		System.out.println("abc.da.ad".replace(".", "1"));   //abc1da1ad
		
		System.out.println(22222);
		
		//10 String [] split(String regex) 分割字符串，需要指定分割符，返回字符串数组，支持正则表达式
		String mytime="2021,07,13";
		//以逗号分割，返回字符串数组
		String[] time=mytime.split(",");
		for(String string:time){
			System.out.println(string);//20170713
		}
		//11 String substring(int beginIndex);获取该字符串中，以某个下标为起始的子字符串（包含）
		//heyhrwy
		System.out.println("vuihwqu".substring(3));  //hwqu
		//12 String substring(int beginIndex,int endIndex);获取该字符串中，以某个下标为起始（包含）到指定位置
		//（不包含）
		//注意，起始包含，结束不包含
		System.out.println("abcdefg".substring(3,5)); //de
		//13 String trim() 去除字符串两边的空格
		System.out.println("a      b      c      ".trim()); //a      b      c  只能去两边的空格，中间不不能去
		
		//14 转大小写
		System.out.println("abcdEFG".toUpperCase());  //ABCDEFG   大写
		
		System.out.println("abcdEFG".toLowerCase());  //abcdefg   小写
		
		//输出一个引用类型的时候，会自动调用该对象的toString方法
		Object obj=null;
	    //当obj为null时，却不会出现空指针异常
				System.out.println(obj); //null
				//15  static String valueOf; 调用指定对象的toString方法，并且使用三目运算符屏蔽了空指针异常
				System.out.println(String.valueOf(obj)); //null
		
	}
 
}

package day_7_13API;
 
public class String_6 {
	public static void main(String[] args){
		String s1="ab";
		String a="a";
		String b="b";
		//在编译阶段，就会把+号去掉，就等于是ab
		//所以使用==s1 和s2是相等的
		String s2="a"+"b";
		//编译阶段 是没有办法确定a和b的，因为还没有运行，空间还没有
		//最终还是会转换为StringBuffer进行拼接
		//拼接完后再转换为String类型，转换的时候是 new String ()进行转换的
		//所以s1 ==s3 false
		String s3=a+b;
		System.out.println(s1==s2);
		System.out.println(s1==s3);
	
	}
}

注意

package day_7_13API;
 
public class String_6 {
	public static void main(String[] args){
		String s1="ab";
		String a="a";
		String b="b";
		//在编译阶段，就会把+号去掉，就等于是ab
		//所以使用==s1 和s2是相等的
		String s2="a"+"b";
		//编译阶段 是没有办法确定a和b的，因为还没有运行，空间还没有
		//最终还是会转换为StringBuffer进行拼接
		//拼接完后再转换为String类型，转换的时候是 new String ()进行转换的
		//所以s1 ==s3 false
		String s3=a+b;
		System.out.println(s1==s2);
		System.out.println(s1==s3);
	
	}
}

1.  StringBuffer和StringBuilder

package day_7_13API;
/**
 * StringBuffer和StringBuilder是什么
 * 是一个可变的字符串缓冲区，适合做拼接操作
 * 底层也是char数组，只不过默认长度是16，而字符串内容多少长度就是多少
 * 
 * 先定义好长度，用来容纳更多的字符
 * 如果预留的空间长度不够，会进行自动扩充
 * 默认长度是16，扩大容量为（当前容量+1）*2，16-->34-->70
 * 
 * 
 * StringBuffer和 StringBuilder区别
 *    StringBuffer; 非线性安全，在多线程环境下使用,可能出现问题，所以常用于方法
 *    StringBuilder  线程安全，在多线程环境下使用，不会出现问题，所以常用于类中
 *    
 * @author 啊超
 * @Date 2021年7月13日
 */
public class String_5 {
	public static void main(String[] args){
		//创建字符串缓冲区
		StringBuilder sb=new StringBuilder();
		//尾部添加数据
		sb.append("a");
		sb.append("b");
		//reutrn this 所以可以链式调用
		sb.append("c").append("d");  //abcd
		
		System.out.println(sb);
		
		//1 反转     .reverse()
		System.out.println(sb.reverse());   //dcba
		
		//2 指定位置添加数据
		sb.insert(1,"2" );
		System.out.println(sb);  //d2cba
		// 已有元素个数
		System.out.println(sb.length());  //5
		//3 当前数组的容量 。value.length    .capacity
		System.out.println(sb.capacity());   //16
		//把sb 转换为String类型
		String s=sb.toString();	
	}
 
}
 
 
 
 
 
 
 
 
 
 

包装类

包装类 : 封装了基本数据类型的一些操作,更加方便使用
 * java中有8中基本数据类型
 *         byte          java.lang.Byte
 *         short          java.lang.Short
 *         int             java.lang.Integer
 *         long         java.lang.Long
 *         float          java.lang.Float
 *         double         java.lang.Double
 *         boolean      java.lang.Boolean
 *         char             java.lang.Character
 * 

使用

public class Integer_01 {
	public static void main(String[] args) {
		// 基本类型
		byte b1 = 10;
		// 引用类型
		Byte b2 = new Byte(b1);
		m1(b2);
	}
	public static void m1(Object obj){
		// 由于 Byte Integer这些 都覆写toString方法,所以不是内存地址,而是值
		System.out.println(obj);
	}
}

Integer

基本使用

public class Integer_02 {
 
	public static void main(String[] args) {
		// 获取最大值和最小值
		System.out.println(Integer.MAX_VALUE);
		System.out.println(Integer.MIN_VALUE);
		System.out.println(Long.MAX_VALUE);
		System.out.println(Byte.MAX_VALUE);
		
		// 创建Integer类型的对象
		// 把基本类型转换为引用类型 int --> Integer
		Integer i1 = new Integer(10);
		// 把纯数字的字符串转换为Integer类型,必须是纯数字,因为是整数,所以小数点也不能有
		Integer i2 = new Integer("12");
		System.out.println(i1);
		System.out.println(i2);
		// 如果不是纯数字,会报错
		//  java.lang.NumberFormatException: For input string: "2.3"
		Integer i3 = new Integer("2.3");
	}
}

常用方法

 

 类型转换

public class Integer_04 {
 
	public static void main(String[] args) {
		// 1 int --> Integer
		Integer i1 = Integer.valueOf(19);
		
		// 2 Integer --> int
		int i2 = i1.intValue();
		
		// 3 String --> Integer
		Integer i3 = Integer.valueOf("22");
		
		// 4 Integer --> String
		String i4 = i3.toString();
		
		// 5 int --> String
		String i5 = i2 + "";
		
		// 6 String --> int
		int i6 = Integer.parseInt(i5);
	}
}

装箱和拆箱

 java1.5开始,引入了自动装箱和自动拆箱
 * 	
 * 自动装箱 : 把 基本类型 自动转换为对应的封装类类型 就是自动装箱
 * 
 * 自动拆箱 : 把 包装类类型 自动转换为对应的基本类型 就是自动拆箱
 * 
 * 装箱和拆箱是在编译阶段完成的

public class Integer_05 {
	public static void main(String[] args) {
		// 1.5之前 这样写
		Integer i1 = Integer.valueOf(22);
		int i2 = i1.intValue();
		
		// 1.5开始 这样写
		Integer i3 = 22;// 编译后 自动转换为 Integer.valueOf(22);
		int i4 = i3; // 编译后 自动转换为 i3.intValue();
		// 先进行自动装箱为Integer类型,然后向上转型发生多态 为 Object 类型
		// 编译后转换为  m1(Integer.valueOf(3123));
		m1(3123);
	}
	public static void m1(Object obj){
		System.out.println(obj);
	}
}

 整形常量池

 

 

 

 

System

System类提供的public static long currentTimeMillis()用来返回当前时 间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。

此方法适于计算时间差。

lSystem类代表系统，系统级的很多属性和控制方法都放置在该类的内部。 该类位于java.lang包。

l由于该类的构造器是private的，所以无法创建该类的对象，也就是无法实 例化该类。其内部的成员变量和成员方法都是static的，所以也可以很方便 的进行调用。

l成员变量

ØSystem类内部包含in、out和err三个成员变量，分别代表标准输入流

(键盘输入)，标准输出流(显示器)和标准错误输出流(显示器)。

l成员方法

Ønative long currentTimeMillis()：

该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时

间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。

Øvoid exit(int status)：

该方法的作用是退出程序。其中status的值为0代表正常退出，非零代表

异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。

public class System_01 {
	public static void main(String[] args) {
		// 计算时间差
		// currentTimeMillis : 获取当前系统时间对应的毫秒数
		long startTime = System.currentTimeMillis();
		System.out.println("正在执行");
		long endTime = System.currentTimeMillis();
		System.out.println("耗时 : "+(endTime-startTime));
		
		// 退出程序,0 表示正常退出
		// 一般用于图形界面 关闭窗口
		System.exit(0);
		// 执行不到
		System.out.println(222);
	}
}

Date

时间类, 1970.1.1 8:00:00

构造方法

package _03_Date;
 
import java.util.Date;
 
public class Date_01 {
 
	public static void main(String[] args) {
		// 无参 获取当前系统时间
		Date d1 = new Date();
		// 传入的是毫秒数,时间原点到指定毫秒数的时间
		Date d2 = new Date(1000);
		// Tue Jul 13 15:40:50 CST 2021
		System.out.println(d1);
		// Thu Jan 01 08:00:01 CST 1970
		System.out.println(d2);
	}
}

时间格式化

ublic class Date_02 {
	public static void main(String[] args) throws ParseException {
		// 获取当前系统时间
		Date d1 = new Date();
		/**
		 * 年 y   
		 * 月 M
		 * 日 d
		 * 时 H
		 * 分 m
		 * 秒 s
		 * 毫秒 S
		 */
		// 创建时间格式化对象
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss SSS");
		// 格式化当前时间
		String strTime = sdf.format(d1);
		// 2021年07月13日 15:46:01 324
		System.out.println(strTime);
		
		strTime = "2021年07月13日 15:46:01 324";
		Date d2 = sdf.parse(strTime);
		// Tue Jul 13 15:46:01 CST 2021
		System.out.println(d2);
	}
}

日历

public class Date_03 {
 
	public static void main(String[] args) {
		// 创建日历
		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);
		// 获取时 , HOUR_OF_DAY 24小时  HOUR 12小时
		int hour = c.get(Calendar.HOUR_OF_DAY);
		// 获取分
		int minute = c.get(Calendar.MINUTE);
		// 获取秒
		int second = c.get(Calendar.SECOND);
		// 获取星期 , 第一天是周日
		int weekday  = c.get(Calendar.DAY_OF_WEEK);
		System.out.println(year);
		System.out.println(month);
		System.out.println(day);
		System.out.println(hour);
		System.out.println(minute);
		System.out.println(second);
		System.out.println(weekday);
	}
}