Arrays:针对数组进行操作的工具类。
- Arrays的常用成员方法：
public static String toString(int[] a) //把数组转成字符串
public static void sort(int[] a) //对数组进行排序
public static int binarySearch(int[] a,int key) //二分查找- toString()源码如下：
public static String toString(int[] a) {
if (a == null)
return "null";
int iMax = a.length - 1;
if (iMax == -1)
return "[]";
StringBuilder b = new StringBuilder();
b.append('[');
for (int i = 0; ; i++) {
b.append(a[i]);
if (i == iMax)
return b.append(']').toString();
b.append(", ");
}
}- binarySearch()调用的是binarySearch0(),源码如下：
private static int binarySearch0(int[] a, int fromIndex, int toIndex,int key) {
int low = fromIndex;
int high = toIndex - 1;
while (low <= high) {
int mid = (low + high) >>> 1;
int midVal = a[mid];
if (midVal < key)
low = mid + 1;
else if (midVal > key)
high = mid - 1;
else
return mid; // key found
}
return -(low + 1); // key not found.
}- 使用示例：
public class ArraysDemo {
public static void main(String[] args) {
// 定义一个数组
int[] arr = { 24, 69, 80, 57, 13 };
// public static String toString(int[] a) 把数组转成字符串
System.out.println("排序前：" + Arrays.toString(arr));//排序前：[24, 69, 80, 57, 13]
// public static void sort(int[] a) 对数组进行排序
Arrays.sort(arr);
System.out.println("排序后：" + Arrays.toString(arr));//排序后：[13, 24, 57, 69, 80]
// [13, 24, 57, 69, 80]
// public static int binarySearch(int[] a,int key) 二分查找
System.out.println("binarySearch:" + Arrays.binarySearch(arr, 57));//binarySearch:2
System.out.println("binarySearch:" + Arrays.binarySearch(arr, 577));//binarySearch:-6
}
}BigDecimal类：不可变的、任意精度的有符号十进制数,可以解决数据丢失问题。
看如下程序，写出结果
public static void main(String[] args) {
System.out.println(0.09 + 0.01);
System.out.println(1.0 - 0.32);
System.out.println(1.015 * 100);
System.out.println(1.301 / 100);
System.out.println(1.0 - 0.12);
}输出结果
0.09999999999999999
0.6799999999999999
101.49999999999999
0.013009999999999999
0.88结果和我们想的有一点点不一样，这是因为浮点数类型的数据存储和整数不一样导致的。 它们大部分的时候，都是带有有效数字位。由于在运算的时候，float类型和double很容易丢失精度， 所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal。
- BigDecimal的常用成员方法：
public BigDecimal(String val) //构造方法
public BigDecimal add(BigDecimal augend) //加
public BigDecimal subtract(BigDecimal subtrahend)//减
public BigDecimal multiply(BigDecimal multiplicand) //乘
public BigDecimal divide(BigDecimal divisor) //除
public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)//除法，scale：几位小数，roundingMode：如何舍取- 使用BigDecimal改进
public static void main(String[] args) {
/*System.out.println(0.09 + 0.01);
System.out.println(1.0 - 0.32);
System.out.println(1.015 * 100);
System.out.println(1.301 / 100);
System.out.println(1.0 - 0.12);*/
BigDecimal bd1 = new BigDecimal("0.09");
BigDecimal bd2 = new BigDecimal("0.01");
System.out.println("add:" + bd1.add(bd2));//add:0.10
System.out.println("-------------------");
BigDecimal bd3 = new BigDecimal("1.0");
BigDecimal bd4 = new BigDecimal("0.32");
System.out.println("subtract:" + bd3.subtract(bd4));//subtract:0.68
System.out.println("-------------------");
BigDecimal bd5 = new BigDecimal("1.015");
BigDecimal bd6 = new BigDecimal("100");
System.out.println("multiply:" + bd5.multiply(bd6));//multiply:101.500
System.out.println("-------------------");
BigDecimal bd7 = new BigDecimal("1.301");
BigDecimal bd8 = new BigDecimal("100");
System.out.println("divide:" + bd7.divide(bd8));//divide:0.01301
//四舍五入
System.out.println("divide:"
+ bd7.divide(bd8, 3, BigDecimal.ROUND_HALF_UP));//保留三位有效数字
//divide:0.013
System.out.println("divide:"
+ bd7.divide(bd8, 8, BigDecimal.ROUND_HALF_UP));//保留八位有效数字
//divide:0.01301000
}BigInteger:可以让超过Integer范围内的数据进行运算
public static void main(String[] args) {
Integer num = new Integer("2147483647");
System.out.println(num);
//Integer num2 = new Integer("2147483648");
// Exception in thread "main" java.lang.NumberFormatException: For input string: "2147483648"
//System.out.println(num2);
// 通过 BigIntege来创建对象
BigInteger num2 = new BigInteger("2147483648");
System.out.println(num2);
}- BigInteger的常用成员方法：
public BigInteger add(BigInteger val) //加
public BigInteger subtract(BigInteger val) //减
public BigInteger multiply(BigInteger val) //乘
public BigInteger divide(BigInteger val) //除
public BigInteger[] divideAndRemainder(BigInteger val)//返回商和余数的数组- 使用实例：
public class BigIntegerDemo {
public static void main(String[] args) {
Integer num = new Integer("2147483647");
System.out.println(num);
//Integer num2 = new Integer("2147483648");
// Exception in thread "main" java.lang.NumberFormatException: For input string: "2147483648"
//System.out.println(num2);
// 通过 BigIntege来创建对象
BigInteger num2 = new BigInteger("2147483648");
System.out.println(num2);
}
}public class BigIntegerDemo2 {
public static void main(String[] args) {
BigInteger bi1 = new BigInteger("100");
BigInteger bi2 = new BigInteger("50");
// public BigInteger add(BigInteger val):加
System.out.println("add:" + bi1.add(bi2)); //add:150
// public BigInteger subtract(BigInteger Val):减
System.out.println("subtract:" + bi1.subtract(bi2));//subtract:50
// public BigInteger multiply(BigInteger val):乘
System.out.println("multiply:" + bi1.multiply(bi2));//multiply:5000
// public BigInteger divide(BigInteger val):除
System.out.println("divide:" + bi1.divide(bi2));//divide:2
// public BigInteger[] divideAndRemainder(BigInteger val):返回商和余数的数组
BigInteger[] bis = bi1.divideAndRemainder(bi2);
System.out.println("divide：" + bis[0]);//divide：2
System.out.println("remainder：" + bis[1]);//remainder：0
}
}Calendar为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法， 并为操作日历字段（例如获得下星期的日期）提供了一些方法。
Calendar中常用的方法：
public int get(int field) //返回给定日历字段的值。日历类中的每个日历字段都是静态的成员变量，并且是int类型。
public void add(int field,int amount)//根据给定的日历字段和对应的时间，来对当前的日历进行操作。
public final void set(int year,int month,int date)//设置当前日历的年月日- 使用示例：
public class CalendarDemo {
public static void main(String[] args) {
// 其日历字段已由当前日期和时间初始化：
Calendar rightNow = Calendar.getInstance(); // 子类对象
int year=rightNow.get(Calendar.YEAR);
int month=rightNow.get(Calendar.MONTH);//注意月份是从0开始的
int date=rightNow.get(Calendar.DATE);
System.out.println(year + "年" + (month + 1) + "月" + date + "日");
//2018年12月25日
}
}- 使用示例2:
public class CalendarDemo2 {
public static void main(String[] args) {
// 其日历字段已由当前日期和时间初始化：
Calendar calendar = Calendar.getInstance(); // 子类对象
System.out.println(getYearMonthDay(calendar));//2018年12月25日
//三年前的今天
calendar.add(Calendar.YEAR,-3);
System.out.println(getYearMonthDay(calendar));//2015年12月25日
//5年后的10天前
calendar.add(Calendar.YEAR,5);
calendar.add(Calendar.DATE,-10);
System.out.println(getYearMonthDay(calendar));//2020年12月15日
//设置 2011年11月11日
calendar.set(2011,10,11);
System.out.println(getYearMonthDay(calendar));//2011年11月11日
}
//获取年、月、日
public static String getYearMonthDay(Calendar calendar){
int year=calendar.get(Calendar.YEAR);
int month=calendar.get(Calendar.MONTH);
int date=calendar.get(Calendar.DATE);
return year + "年" + (month + 1) + "月" + date + "日";
}
}- 小练习：获取任意一年的二月有多少天
/**
*获取任意一年的二月有多少天
*分析：
* A:键盘录入任意的年份
* B:设置日历对象的年月日
* 年就是输入的数据
* 月是2
* 日是1
* C:把时间往前推一天，就是2月的最后一天
* D:获取这一天输出即可
*/
public class CalendarTest {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int year=sc.nextInt();
Calendar c= Calendar.getInstance();
c.set(year,2,1); //得到的就是该年的3月1日
c.add(Calendar.DATE,-1);//把时间往前推一天，就是2月的最后一天
//public void add(int field,int amount):根据给定的日历字段和对应的时间，来对当前的日历进行操作。
System.out.println(year+"年，二月有"+c.get(Calendar.DATE)+"天");
}
}Character 类在对象中包装一个基本类型 char 的值.此外，该类提供了几种方法， 以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然。
- Character常用方法：
Character(char value) //构造方法
public static boolean isUpperCase(char ch) //判断给定的字符是否是大写字符
public static boolean isLowerCase(char ch) //判断给定的字符是否是小写字符
public static boolean isDigit(char ch) //判断给定的字符是否是数字字符
public static char toUpperCase(char ch) //把给定的字符转换为大写字符
public static char toLowerCase(char ch) //把给定的字符转换为小写字符- 使用示例：
public class CharacterDemo {
public static void main(String[] args) {
// public static boolean isUpperCase(char ch):判断给定的字符是否是大写字符
System.out.println("isUpperCase:" + Character.isUpperCase('A'));//true
System.out.println("isUpperCase:" + Character.isUpperCase('a'));//false
System.out.println("isUpperCase:" + Character.isUpperCase('0'));//false
System.out.println("-----------------------------------------");
// public static boolean isLowerCase(char ch):判断给定的字符是否是小写字符
System.out.println("isLowerCase:" + Character.isLowerCase('A'));//false
System.out.println("isLowerCase:" + Character.isLowerCase('a'));//true
System.out.println("isLowerCase:" + Character.isLowerCase('0'));//false
System.out.println("-----------------------------------------");
// public static boolean isDigit(char ch):判断给定的字符是否是数字字符
System.out.println("isDigit:" + Character.isDigit('A'));//false
System.out.println("isDigit:" + Character.isDigit('a'));//false
System.out.println("isDigit:" + Character.isDigit('0'));//true
System.out.println("-----------------------------------------");
// public static char toUpperCase(char ch):把给定的字符转换为大写字符
System.out.println("toUpperCase:" + Character.toUpperCase('A'));//A
System.out.println("toUpperCase:" + Character.toUpperCase('a'));//A
System.out.println("-----------------------------------------");
// public static char toLowerCase(char ch):把给定的字符转换为小写字符
System.out.println("toLowerCase:" + Character.toLowerCase('A'));//a
System.out.println("toLowerCase:" + Character.toLowerCase('a'));//a
}
}- 小练习：统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
/**
* 统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
*
* 分析：
* A:定义三个统计变量。
* int bigCont=0;
* int smalCount=0;
* int numberCount=0;
* B:键盘录入一个字符串。
* C:把字符串转换为字符数组。
* D:遍历字符数组获取到每一个字符
* E:判断该字符是
* 大写 bigCount++;
* 小写 smalCount++;
* 数字 numberCount++;
* F:输出结果即可
*/
public class CharacterTest {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String str=sc.nextLine();
printCount(str);
printCount2(str);
}
//原来的写法
public static void printCount(String str) {
int numberCount=0;
int lowercaseCount=0;
int upercaseCount=0;
for(int index=0;index<str.length();index++){
char ch=str.charAt(index);
if(ch>='0' && ch<='9'){
numberCount++;
}else if(ch>='A' && ch<='Z'){
upercaseCount++;
}else if(ch>='a' && ch<='z'){
lowercaseCount++;
}
}
System.out.println("数字有"+numberCount+"个");
System.out.println("小写字母有"+lowercaseCount+"个");
System.out.println("大写字母有"+upercaseCount+"个");
}
//使用包装类来改进
public static void printCount2(String str) {
int numberCount=0;
int lowercaseCount=0;
int upercaseCount=0;
for(int index=0;index<str.length();index++){
char ch=str.charAt(index);
if(Character.isDigit(ch)){
numberCount++;
}else if(Character.isUpperCase(ch)){
upercaseCount++;
}else if(Character.isLowerCase(ch)){
lowercaseCount++;
}
}
System.out.println("数字有"+numberCount+"个");
System.out.println("小写字母有"+lowercaseCount+"个");
System.out.println("大写字母有"+upercaseCount+"个");
}
}Date:表示特定的瞬间，精确到毫秒。
- Date常用成员方法：
Date() //根据当前的默认毫秒值创建日期对象
Date(long date) //根据给定的毫秒值创建日期对象
public long getTime() //获取时间，以毫秒为单位
public void setTime(long time) //设置时间- Date使用示例：
/**
* 把一个毫秒值转换为Date，有两种方式：
* (1)构造方法
* (2)setTime(long time)
*/
public class DateDemo {
public static void main(String[] args) {
// Date():根据当前的默认毫秒值创建日期对象
Date d = new Date();
System.out.println("d:" + d);
//d:Tue Dec 25 20:01:17 GMT+08:00 2018 --> 当前时间
// Date(long date)：根据给定的毫秒值创建日期对象
//long time = System.currentTimeMillis();
long time = 1000 * 60 * 60; // 1小时
Date d2 = new Date(time);
System.out.println("d2:" + d2);
//格林威治时间 1970年01月01日00时00分00
//Thu Jan 01 09:00:00 GMT+08:00 1970 GMT+表示 标准时间加8小时，因为中国是东八区
// 获取时间
long time2 = d.getTime();
System.out.println(time2); //1545739438466 毫秒
System.out.println(System.currentTimeMillis());
// 设置时间
d.setTime(1000*60*60);
System.out.println("d:" + d);
//Thu Jan 01 09:00:00 GMT+08:00 1970
}
}DateForamt:可以进行日期和字符串的格式化和解析，但是由于是抽象类，所以使用具体子类SimpleDateFormat。 SimpleDateFormat的构造方法：
SimpleDateFormat() //默认模式
SimpleDateFormat(String pattern) //给定的模式这个模式字符串该如何写呢? 通过查看API，我们就找到了对应的模式:
| 中文说明 | 模式字符 |
|---|---|
| 年 | y |
| 月 | M |
| 日 | d |
| 时 | H |
| 分 | m |
| 秒 | s |
- Date类型和String类型的相互转换
public class DateFormatDemo {
public static void main(String[] args) {
Date date=new Date();
SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日");
String s=dateToString(date,sdf);
System.out.println(s); //2018年12月25日
System.out.println(stringToDate(s,sdf));//Tue Dec 25 00:00:00 GMT+08:00 2018
}
/**
* Date -- String(格式化)
* public final String format(Date date)
*/
public static String dateToString(Date d, SimpleDateFormat sdf) {
return sdf.format(d);
}
/**
* * String -- Date(解析)
* public Date parse(String source)
*/
public static Date stringToDate(String s, SimpleDateFormat sdf){
Date date=null;
try {
date=sdf.parse(s);
} catch (ParseException e) {
e.printStackTrace();
}
return date;
}
}- 小练习： 算一下你来到这个世界多少天?
/**
* *
* 算一下你来到这个世界多少天?
*
* 分析：
* A:键盘录入你的出生的年月日
* B:把该字符串转换为一个日期
* C:通过该日期得到一个毫秒值
* D:获取当前时间的毫秒值
* E:用D-C得到一个毫秒值
* F:把E的毫秒值转换为年
* /1000/60/60/24
*/
public class DateTest {
public static void main(String[] args) throws ParseException {
// 键盘录入你的出生的年月日
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的出生年月日(格式 yyyy-MM-dd):");
String line = sc.nextLine();
// 把该字符串转换为一个日期
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date d = sdf.parse(line);
long birth=d.getTime(); //出生的时间
long current=System.currentTimeMillis();//当前时间
long days=(current-birth)/1000/60/60/24;
System.out.println("你出生了"+days+"天");
}
}Java就针对每一种基本数据类型提供了对应的类类型:
| 基础类型 | 包装类类型 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
用于基本数据类型与字符串之间的转换。
- Integer的常用成员方法：
public Integer(int value)
public Integer(String s) //注意：这个字符串必须是由数字字符组成- int和String的相互转化：
String.valueOf(number) //int --> String
Integer.parseInt(s) //String --> intpublic static void main(String[] args) {
System.out.println(intToString(100)); //100
System.out.println(stringToInt("100")); //100
}
//int --> String
public static String intToString(int number) {
//方式一
/*String strNumber=""+number;
return strNumber;*/
//方式二
String strNumber=String.valueOf(number);
return strNumber;
}
//String --> int
public static int stringToInt(String strNumber) {
//方式一
/*Integer number=new Integer(strNumber);
return number;*/
//方式二
Integer number=Integer.parseInt(strNumber);
return number;
}- 常用的进制转换：
//常用的基本进制转换
public static String toBinaryString(int i)
public static String toOctalString(int i)
public static String toHexString(int i)
//十进制到其他进制
public static String toString(int i,int radix)//进制的范围：2-36,为什么呢?0,...9,a...z(10个数字+26个字母)
//其他进制到十进制
public static int parseInt(String s,int radix)public class IntegerDemo3 {
public static void main(String[] args) {
//test();
//test2();
test3();
}
//常用的基本进制转换
public static void test(){
System.out.println(Integer.toBinaryString(100));//1100100
System.out.println(Integer.toOctalString(100));//144
System.out.println(Integer.toHexString(100));//64
System.out.println("-----------------------------");
}
//十进制到其他进制
public static void test2(){
System.out.println(Integer.toString(100, 10));//100
System.out.println(Integer.toString(100, 2));//1100100
System.out.println(Integer.toString(100, 8));//144
System.out.println(Integer.toString(100, 16));//64
System.out.println(Integer.toString(100, 5));//400
System.out.println(Integer.toString(100, 7));//202
//进制的范围在2-36之间，超过这个范围，就作为十进制处理
System.out.println(Integer.toString(100, -7)); //100
System.out.println(Integer.toString(100, 70));//100
System.out.println(Integer.toString(100, 1));//100
System.out.println(Integer.toString(100, 37));//100
System.out.println(Integer.toString(100, 17));//5f
System.out.println(Integer.toString(100, 32));//34
System.out.println(Integer.toString(100, 36));//2s
System.out.println("-------------------------");
}
//任意进制转换为十进制
public static void test3(){
System.out.println(Integer.parseInt("100", 10));//100
System.out.println(Integer.parseInt("100", 2));//4
System.out.println(Integer.parseInt("100", 8));//64
System.out.println(Integer.parseInt("100", 16));//256
System.out.println(Integer.parseInt("100", 23));//529
//NumberFormatException,因为二进制是不可能存在 123的
//System.out.println(Integer.parseInt("123", 2));
}
}- JDK5的新特性
自动装箱：把基本类型转换为包装类类型
自动拆箱：把包装类类型转换为基本类型
public class IntegerDemo4 {
public static void main(String[] args) {
Integer num=null;
if(num!=null){
num+=100;
System.out.println(num);
}
test(); //num:200
test2(); //num:200
}
//自动装箱,拆箱
public static void test() {
Integer num=100;
//自动装箱，实际上就是 Integer num=Integer.valueOf(100)
num+=100;
//先拆箱再装箱 num.intValue()+100=200 --> Integer num=Integer.valueOf(num.intValue()+100)
System.out.println(new StringBuilder("num:").append(num).toString());
}
//手动拆装箱
public static void test2() {
Integer num=Integer.valueOf(100); //手动装箱
num=Integer.valueOf(num.intValue()+100); //先手动拆箱，进行运算后，再手动装箱
System.out.println(new StringBuilder("num:").append(num).toString());
}
}- 小练习：看程序写结果
public class IntegerTest {
public static void main(String[] args) {
Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
System.out.println(i1 == i2);
System.out.println(i1.equals(i2));
System.out.println("-----------");
Integer i3 = new Integer(128);
Integer i4 = new Integer(128);
System.out.println(i3 == i4);
System.out.println(i3.equals(i4));
System.out.println("-----------");
Integer i5 = 128;
Integer i6 = 128;
System.out.println(i5 == i6);
System.out.println(i5.equals(i6));
System.out.println("-----------");
Integer i7 = 127;
Integer i8 = 127;
System.out.println(i7 == i8);
System.out.println(i7.equals(i8));
}
}输出结果：
false
true
-----------
false
true
-----------
false
true
-----------
true
true分析： Integer的数据直接赋值，如果在-128到127之间，会直接从缓冲池里获取数据。 通过查看源码，针对-128到127之间的数据，做了一个数据缓冲池IntegerCache， 如果数据是该范围内的，每次并不创建新的空间。
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
private static class IntegerCache {
static final int low = -128; //low=-128
static final int high;
static final Integer cache[];
static {
// high value may be configured by property
int h = 127;
//...
}
high = h; //high=127Object类是类层次结构的根类。每个类都使用 Object 作为超类。每个类都直接或者间接的继承自Object类。
- Object类的方法:
public int hashCode() //返回该对象的哈希码值。
// 注意：哈希值是根据哈希算法计算出来的一个值，这个值和地址值有关，但是不是实际地址值。
public final Class getClass() //返回此 Object 的运行时类
public String toString() //返回该对象的字符串表示。
protected Object clone() //创建并返回此对象的一个副本。可重写该方法
protected void finalize()
//当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。用于垃圾回收，但是什么时候回收不确定。Scanner:用于接收键盘录入数据。
- 使用Scanner三部曲：
A:导包
B :创建对象
C :使用相应方法
- Scanner常用成员方法
Scanner(InputStream source) //构造方法
public boolean hasNextXxx() //判断是否是某种类型的元素,Xxx表示类型，比如 public boolean hasNextInt()
public Xxx nextXxx() //获取该元素，Xxx表示类型，比如public int nextInt()注意：InputMismatchException：表示输入的和你想要的不匹配
- 使用示例1：
public class ScannerDemo {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
if(sc.hasNextInt()){
int x=sc.nextInt();
System.out.println("x="+x);
}else{
System.out.println("输入的数据有误");
}
}
}- 先获取一个数值，换行后，再获取一个字符串，会出现问题。主要原因：就是换行符号的问题。如何解决呢？
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
//输入 12 换行后在输出 "sss"
int x=sc.nextInt();
System.out.println("x:"+x); //x:12
String line=sc.nextLine(); //这里会有问题 因为会将换行符当作字符输输入
System.out.println("line:"+line); //line:
}解决方案一:先获取一个数值后，再创建一个新的键盘录入对象获取字符串。
public static void method() {
Scanner sc=new Scanner(System.in);
int x=sc.nextInt();
System.out.println("x:"+x);
Scanner sc2=new Scanner(System.in);
String line=sc2.nextLine();
System.out.println("line:"+line);
}解决方案二：把所有的数据都先按照字符串获取，然后要什么，就进行相应的转换。
public static void method2() {
Scanner sc=new Scanner(System.in);
String xStr=sc.nextLine();
String line=sc.nextLine();
int x=Integer.parseInt(xStr);
System.out.println("x:"+x);
System.out.println("line:"+line);
}字符串：就是由多个字符组成的一串数据。也可以看成是一个字符数组。
- String的构造方法方法：
//String的构造方法
public String() //空构造
public String(byte[] bytes) //把字节数组转成字符串
public String(byte[] bytes,int index,int length) //把字节数组的一部分转成字符串
public String(char[] value) //把字符数组转成字符串
public String(char[] value,int index,int count) //把字符数组的一部分转成字符串,第三个参数表示的是数目
public String(String original) //把字符串常量值转成字符串public class StringDemo {
public static void main(String[] args) {
//public String():空构造
String s=new String();
System.out.println("s:"+s);
System.out.println("s.length="+s.length());
System.out.println("-----------------------");
//public String(byte[] bytes):把字节数组转成字符串
byte[] bys={97,98,99,100,101};
String s2=new String(bys);
System.out.println("s2:"+s2);
System.out.println("s2.length="+s2.length());
System.out.println("-----------------------");
//public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串
String s3=new String(bys,0,3); //从0位置开始,3个字符
System.out.println("s3:"+s3);//s3:abc
System.out.println("s3.length="+s3.length());//s3.length=3
System.out.println("-----------------------");
//public String(char[] value):把字符数组转成字符串
char[] chs={'a','b','c','d','e'};
String s4=new String(chs); //从0位置开始,3个字符
System.out.println("s4:"+s4);
System.out.println("s4.length="+s4.length());
System.out.println("-----------------------");
//public String(char[] value,int index,int count):把字符数组的一部分转成字符串
String s5=new String(chs,0,3); //从0位置开始,3个字符
System.out.println("s5:"+s5);
System.out.println("s5.length="+s5.length());
System.out.println("-----------------------");
//public String(String original):把字符串常量值转成字符串
String s6=new String("abcde");
System.out.println("s6:"+s6);
System.out.println("s6.length="+s6.length());
}
}- 字符串的特点：一旦被赋值，就不能改变
public static void test() {
String s = "hello";
s += "world";
System.out.println("s:" + s); // helloworld
}- 小练习：看程序，写结果：
public static void test2(){
String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2);
System.out.println(s1.equals(s2));
String s3 = new String("hello");
String s4 = "hello";
System.out.println(s3 == s4);
System.out.println(s3.equals(s4));
String s5 = "hello";
String s6 = "hello";
System.out.println(s5 == s6);
System.out.println(s5.equals(s6));
}输出结果：
false
true
false
true
true
true分析：
=和qeuals的区别
==:比较引用类型，比较的是地址值是否相同
equals:比较引用类型，默认也是比较地址值是否相同
String类重写了equals()方法，比较的是内容是否相同。
String s = new String(“hello”)和String s = “hello”的区别？
前者会创建2个对象，后者创建1个对象。更具体的说，前者会创建2个或者1个对象，后者会创建1个或者0个对象。
- String类的判断功能：
boolean equals(Object obj) //比较字符串的内容是否相同,区分大小写
boolean equalsIgnoreCase(String str) //比较字符串的内容是否相同,忽略大小写
boolean contains(String str) //判断大字符串中是否包含小字符串
boolean startsWith(String str) //判断字符串是否以某个指定的字符串开头
boolean endsWith(String str) //判断字符串是否以某个指定的字符串结尾
boolean isEmpty()// 判断字符串是否为空注意：字符串内容为空和字符串对象为空。
String s = "";//字符串内容为空
String s = null;//字符串对象为空public class StringDemo3 {
public static void main(String[] args) {
// 创建字符串对象
String s1 = "helloworld";
String s2 = "helloworld";
String s3 = "HelloWorld";
// boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
System.out.println("equals:" + s1.equals(s2));//true
System.out.println("equals:" + s1.equals(s3));//false
System.out.println("-----------------------");
// boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
System.out.println("equals:" + s1.equalsIgnoreCase(s2));//true
System.out.println("equals:" + s1.equalsIgnoreCase(s3));//true
System.out.println("-----------------------");
// boolean contains(String str):判断大字符串中是否包含小字符串
System.out.println("contains:" + s1.contains("hello"));//true
System.out.println("contains:" + s1.contains("hw"));//false
System.out.println("-----------------------");
// boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
System.out.println("startsWith:" + s1.startsWith("h"));//true
System.out.println("startsWith:" + s1.startsWith("hello"));//true
System.out.println("startsWith:" + s1.startsWith("world"));//false
System.out.println("-----------------------");
//boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾
System.out.println("startsWith:" + s1.endsWith("d"));//true
System.out.println("startsWith:" + s1.endsWith("world"));//true
System.out.println("startsWith:" + s1.endsWith("hello"));//false
System.out.println("-----------------------");
// boolean isEmpty():判断字符串是否为空。
System.out.println("isEmpty:" + s1.isEmpty());//false
String s4 = ""; //字符串内容为空
String s5 = null;//字符串对象为空
System.out.println("isEmpty:" + s4.isEmpty());//true
// NullPointerException
// s5对象都不存在，所以不能调用方法，空指针异常
//System.out.println("isEmpty:" + s5.isEmpty());
}
}- String类的获取功能:
int length() //获取字符串的长度。
char charAt(int index) //获取指定索引位置的字符
int indexOf(int ch) //返回指定字符在此字符串中第一次出现处的索引。为什么这里参数int类型，而不是char类型?原因是：'a'和97其实都可以代表'a'
int indexOf(String str) //返回指定字符串在此字符串中第一次出现处的索引。
int indexOf(int ch,int fromIndex) //返回指定字符在此字符串中从指定位置后第一次出现处的索引。
int indexOf(String str,int fromIndex) //返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
String substring(int start) //从指定位置开始截取字符串,默认到末尾。
String substring(int start,int end) //从指定位置开始到指定位置结束截取字符串。左闭右开public class StringDemo4 {
public static void main(String[] args) {
// 定义一个字符串对象
String s = "helloworld";
// int length():获取字符串的长度。
System.out.println("s.length:" + s.length());//10
System.out.println("----------------------");
// char charAt(int index):获取指定索引位置的字符
System.out.println("charAt:" + s.charAt(7));//r
System.out.println("----------------------");
// int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
System.out.println("indexOf:" + s.indexOf('l'));//2
System.out.println("----------------------");
// int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
System.out.println("indexOf:" + s.indexOf("owo"));//4
System.out.println("----------------------");
// int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
System.out.println("indexOf:" + s.indexOf('l', 4));//8
System.out.println("indexOf:" + s.indexOf('k', 4)); // -1
System.out.println("indexOf:" + s.indexOf('l', 40)); // -1
System.out.println("----------------------");
// int indexOf(String str,intfromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
System.out.println("indexOf:" + s.indexOf("owo", 4));//4
System.out.println("indexOf:" + s.indexOf("ll", 4)); //-1
System.out.println("indexOf:" + s.indexOf("ld", 40)); // -1
System.out.println("----------------------");
// String substring(int start):从指定位置开始截取字符串,默认到末尾。包含start这个索引
System.out.println("substring:" + s.substring(5));//world
System.out.println("substring:" + s.substring(0));//helloworld
System.out.println("----------------------");
// String substring(int start,int
// end):从指定位置开始到指定位置结束截取字符串。包括start索引但是不包end索引
System.out.println("substring:" + s.substring(3, 8));//lowor
System.out.println("substring:" + s.substring(0, s.length()));//helloworld
/**
* 获取 字符串中的每个字符
*/
for(int i=0;i<s.length();i++){
System.out.println(s.charAt(i));
}
}
}- String的转换功能
byte[] getBytes() //字符串转换为字节数组。
char[] toCharArray() //把字符串转换为字符数组。
static String valueOf(char[] chs) //把字符数组转成字符串。
static String valueOf(int i) //把int类型的数据转成字符串。注意：String类的valueOf方法可以把任意类型的数据转成字符串。
String toLowerCase() //把字符串转成小写。
String toUpperCase() //把字符串转成大写。
String concat(String str) //把字符串拼接。public class StringDemo5 {
public static void main(String[] args) {
// 定义一个字符串对象
String s = "JavaSE";
// byte[] getBytes():把字符串转换为字节数组。
byte[] bys = s.getBytes();
for (int x = 0; x < bys.length; x++) {
System.out.println(bys[x]);//74 97 118 97 83 69
}
System.out.println("----------------");
// char[] toCharArray():把字符串转换为字符数组。
char[] chs = s.toCharArray();
for (int x = 0; x < chs.length; x++) {
System.out.println(chs[x]);//J a v a S E
}
System.out.println("----------------");
// static String valueOf(char[] chs):把字符数组转成字符串。
String ss = String.valueOf(chs);
System.out.println(ss);//JavaSE
System.out.println("----------------");
// static String valueOf(int i):把int类型的数据转成字符串。
int i = 100;
String sss = String.valueOf(i);
System.out.println(sss);//100 是字符串
System.out.println("----------------");
// String toLowerCase():把字符串转成小写。
System.out.println("toLowerCase:" + s.toLowerCase());//javase
System.out.println("s:" + s);
// System.out.println("----------------");
// String toUpperCase():把字符串转成大写。
System.out.println("toUpperCase:" + s.toUpperCase());//JAVASE
System.out.println("----------------");
// String concat(String str):把字符串拼接。
String s1 = "hello";
String s2 = "world";
String s3 = s1 + s2;
String s4 = s1.concat(s2);
System.out.println("s3:"+s3);//helloworld
System.out.println("s4:"+s4);//helloworld
}
}- 练习：将一个字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)
/**
* 需求：把一个字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)
* 举例：
* helloWORLD
* 结果：
* Helloworld
*
* A:先获取第一个字符
* B:获取除了第一个字符以外的字符
* C:把A转成大写
* D:把B转成小写
* E:C拼接D
*/
public class StringTest {
public static void main(String[] args) {
String str="helloWORLD";
str=str.substring(0,1).toUpperCase().
concat(str.substring(1).toLowerCase());
System.out.println(str);
}
}- String类的其他功能:
//替换功能：
String replace(char old,char new)
String replace(String old,String new)
//去除字符串两端空格
String trim()
//按字典顺序比较两个字符串
int compareTo(String str)
int compareToIgnoreCase(String str)compareTo()方法源码解析
private final char value[]; //字符串会自动转换为一个字符数组。
/**
* 举例
String s6 = "hello";
String s9 = "xyz";
System.out.println(s6.compareTo(s9));// -16
*/
public int compareTo(String anotherString) {
int len1 = value.length;
int len2 = anotherString.value.length;
int lim = Math.min(len1, len2); //lim=3
char v1[] = value; //v1[h e l l o]
char v2[] = anotherString.value;//v2[x y z]
int k = 0;
while (k < lim) {
char c1 = v1[k];//h
char c2 = v2[k];//x
if (c1 != c2) { //先比较的是对应的字符是否相等
return c1 - c2; //h=104 x=120 104-120=-16
}
k++;
}
//如果在指定位置，字符都相同，则长度相减
return len1 - len2;
}- 练习1：把数组中的数据按照指定个格式拼接成一个字符串。举例：int[] arr = {1,2,3};输出结果：[1, 2, 3]
/**
*
* 需求：把数组中的数据按照指定个格式拼接成一个字符串
* 举例：
* int[] arr = {1,2,3};
* 输出结果：
* "[1, 2, 3]"
* 分析：
* A:定义一个字符串对象，只不过内容为空
* B:先把字符串拼接一个"["
* C:遍历int数组，得到每一个元素
* D:先判断该元素是否为最后一个
* 是：就直接拼接元素和"]"
* 不是：就拼接元素和逗号以及空格
* E:输出拼接后的字符串
*/
public class StringTest2 {
public static void main(String[] args) {
int[] arr={1,2,3,4};
System.out.println(arrayToString(arr));
}
/**
* 把数组中的数据按照指定个格式拼接成一个字符串
*/
public static String arrayToString(int[] arr){
String str="[";
for(int i=0;i<arr.length;i++){
if(i==arr.length-1){
str+=arr[i];
}else{
str+=arr[i]+",";
}
}
str+="]";
return str;
}
}- 练习2：统计大串中小串出现的次数
/**
* 统计大串中小串出现的次数
* 举例：
* 在字符串"woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun"
* 结果：
* java出现了5次
*
* 分析：
* 前提：是已经知道了大串和小串。
* A:定义一个统计变量，初始化值是0
* B:先在大串中查找一次小串第一次出现的位置 ( boolean contains(String str):判断大字符串中是否包含小字符串)
* a:索引是-1，说明不存在了，就返回统计变量
* b:索引不是-1，说明存在，统计变量++
* C:把刚才的索引+小串的长度作为开始位置截取上一次的大串，返回一个新的字符串，并把该字符串的值重新赋值给大串
* D:回到B
*/
public class StringTest3 {
public static void main(String[] args) {
String s1="woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
String s2="java";
System.out.println(smallCount(s2,s1));
}
// 统计大串中小串出现的次数
public static int smallCount(String smallStr,String bigStr) {
int count=0;
int index=bigStr.indexOf(smallStr);
while(index!=-1){
count++;
//把刚才的索引+小串的长度作为开始位置截取上一次的大串
int startIndex=index+smallStr.length();
bigStr=bigStr.substring(startIndex);
index=bigStr.indexOf(smallStr);
}
return count;
}
}- StringBuffer的常用成员方法：
//StirngBuffer的构造方法
public StringBuffer() //无参构造方法
public StringBuffer(int capacity) //指定容量的字符串缓冲区对象
public StringBuffer(String str) //指定字符串内容的字符串缓冲区对象
//StringBuffer的方法
public int capacity() //返回当前容量。 理论值
public int length() //返回长度（字符数）。 实际值public static void main(String[] args) {
// public StringBuffer():无参构造方法
StringBuffer sb = new StringBuffer();
System.out.println("sb:" + sb);
System.out.println("sb.capacity():" + sb.capacity()); //StringBuffer默认的指定容量是16
System.out.println("sb.length():" + sb.length());//0
System.out.println("--------------------------");
// public StringBuffer(int capacity):指定容量的字符串缓冲区对象
StringBuffer sb2 = new StringBuffer(50);
System.out.println("sb2:" + sb2);//""
System.out.println("sb2.capacity():" + sb2.capacity());//50
System.out.println("sb2.length():" + sb2.length());//0
System.out.println("--------------------------");
// public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
StringBuffer sb3 = new StringBuffer("hello");
System.out.println("sb3:" + sb3);//hello
System.out.println("sb3.capacity():" + sb3.capacity());//16+5=21
System.out.println("sb3.length():" + sb3.length());//5
}- StringBuffer的添加功能:
public StringBuffer append(String str) //可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
public StringBuffer insert(int offset,String str) //在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身public static void main(String[] args) {
// 创建字符串缓冲区对象
StringBuffer sb = new StringBuffer();
// 链式编程
sb.append("hello").append(true).append(12).append(34.56);
System.out.println("sb:" + sb);
// public StringBuffer insert(int offset,String
// str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
sb.insert(5, "world");
System.out.println("sb:" + sb);
}- StringBuffer的删除功能
public StringBuffer deleteCharAt(int index) //删除指定位置的字符，并返回本身
public StringBuffer delete(int start,int end) //删除从指定位置开始指定位置结束的内容，并返回本身public static void main(String[] args) {
// 创建对象
StringBuffer sb = new StringBuffer();
// 添加功能
sb.append("hello").append("world").append("java");
// public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身
// 需求：我要删除e这个字符，肿么办?
//sb.deleteCharAt(1);
//public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容，并返回本身
// 需求：我要删除world这个字符串，肿么办?
//sb.delete(5, 10);
//需求:删除所有字符
sb.delete(0,sb.length());
System.out.println("sb:" + sb);
}- StringBuffer的替换功能
public StringBuffer replace(int start,int end,String str) //从start开始到end用str替换public static void main(String[] args) {
// 创建字符串缓冲区对象
StringBuffer sb = new StringBuffer();
// 添加数据
sb.append("hello");
sb.append("world");
sb.append("java");
System.out.println("sb:" + sb);
// public StringBuffer replace(int start,int end,String str):从start开始到end用str替换
// 需求：我要把world这个数据替换为"节日快乐"
sb.replace(5,10,"节日快乐");
System.out.println("sb："+sb);
}- StringBuffer的反转功能：
public StringBuffer reverse()public static void main(String[] args) {
// 创建字符串缓冲区对象
StringBuffer sb = new StringBuffer();
// 添加数据
sb.append("霞青林爱我");
System.out.println("sb:" + sb);//霞青林爱我
// public StringBuffer reverse()
sb.reverse();
System.out.println("sb:" + sb);//我爱林青霞
}- StringBuffer的截取功能:
public String substring(int start) //TODO：注意截取返回的是String,而不是StringBuffer了
public String substring(int start,int end)public static void main(String[] args) {
// 创建字符串缓冲区对象
StringBuffer sb = new StringBuffer();
// 添加元素
sb.append("hello").append("world").append("java");
System.out.println("sb:" + sb);//sb:helloworldjava
// 截取功能
// public String substring(int start)
String s = sb.substring(5);
System.out.println("s:" + s);//s:worldjava
System.out.println("sb:" + sb);//sb:helloworldjava
// public String substring(int start,int end)
String ss = sb.substring(5, 10);//左闭右开
System.out.println("ss:" + ss);//ss:world
System.out.println("sb:" + sb);//sb:helloworldjava
}- String和StringBuffer的相互转换:
public class StringBufferDemo7 {
public static void main(String[] args) {
String s="hello";
System.out.println(stringToStringBuffer(s)); //hello
System.out.println(stringBufferToString(stringToStringBuffer(s)));//hello
}
// String -->StringBuffer
public static StringBuffer stringToStringBuffer(String s) {
// 注意：不能把字符串的值直接赋值给StringBuffer
// StringBuffer sb = "hello";
// StringBuffer sb = s;
// 方式1:通过构造方法
/* StringBuffer sb = new StringBuffer(s);
return sb;*/
// 方式2：通过append()方法
StringBuffer sb2 = new StringBuffer();
sb2.append(s);
return sb2;
}
//StringBuffer -->String
public static String stringBufferToString(StringBuffer buffer){
// 方式1:通过构造方法
/* String str = new String(buffer);
return str;*/
// 方式2：通过toString()方法
String str2 = buffer.toString();
return str2;
}
}- 练习1：将数组拼接成一个字符串
public class StringBufferTest {
public static void main(String[] args) {
int[] arr={1,2,3,4};
System.out.println(arrToString(arr));//[1,2,3,4]
}
public static String arrToString(int[] arr){
StringBuffer buffer=new StringBuffer();
buffer.append("[");
for(int i=0;i<arr.length;i++){
if(i==arr.length-1){
buffer.append(arr[i]);
}else{
buffer.append(arr[i]).append(",");
}
}
buffer.append("]");
return buffer.toString();
}
}- 练习2：判断一个字符串是否是对称字符串
/**
* 判断一个字符串是否是对称字符串
* 例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串
*
* 分析：
* 判断一个字符串是否是对称的字符串，我只需要把
* 第一个和最后一个比较
* 第二个和倒数第二个比较
* ...
* 比较的次数是长度除以2。
*/
public class StringBufferTest2 {
public static void main(String[] args) {
System.out.println(isSymmetry("aba")); //true
System.out.println(isSymmetry2("aabbaa"));//true
}
//通过字符数组的方式来比较
public static boolean isSymmetry(String s){
boolean flag=true;
char[] chs=s.toCharArray();
int len=chs.length;
for(int start=0,end=chs.length-1;start<=end;start++,end--){
if(chs[start]!=chs[end]){
flag=false;
break;
}
}
return flag;
}
//通过StringBuffer的reverse
public static boolean isSymmetry2(String s){
//通过StringBuffer的reverse获取反转字符串s2
String s2=new StringBuffer(s).reverse().toString();
return s2.equals(s);
}
}- 练习3：看程序写结果
public class StringBufferTest3 {
public static void main(String[] args) {
String s1 = "hello";
String s2 = "world";
System.out.println(s1 + "---" + s2);
change(s1, s2);
System.out.println(s1 + "---" + s2);
StringBuffer sb1 = new StringBuffer("hello");
StringBuffer sb2 = new StringBuffer("world");
System.out.println(sb1 + "---" + sb2);
change(sb1, sb2);
System.out.println(sb1 + "---" + sb2);
}
//StringBuffer作为参数传递
public static void change(StringBuffer sb1, StringBuffer sb2) {
sb1 = sb2;
sb2.append(sb1);
}
//String作为参数传递
public static void change(String s1, String s2) {
s1 = s2;
s2 = s1 + s2;
}
}输出结果：
hello---world
hello---world
hello---world
hello---worldworldString作为参数传递，效果和基本类型作为参数传递是一样的。