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