数字与字符串

装箱和拆箱

1.封装类

所有的基本类型，都有对应的类类型 
比如int对应的类是Integer 
这种类就叫做封装类

2.Number类

数字封装类有 
Byte,Short,Integer,Long,Float,Double 
这些类都是抽象类Number的子类

3.基本类型转封装类

4.封装类转基本类型

5.自动装箱

不需要调用构造方法，通过=符号自动把 基本类型 转换为 类类型 就叫装箱

6.自动拆箱

不需要调用Integer的intValue方法，通过=就自动转换成int类型，就叫拆箱

7.int的最大值，最小值

int的最大值可以通过其对应的封装类Integer.MAX_VALUE获取

字符串转换

1.数字转字符串

方法1： 使用String类的静态方法valueOf 
方法2： 先把基本类型装箱为对象，然后调用对象的toString

         int i = 5 ;

         

         //方法1

         String str = String.valueOf(i);

         

         //方法2

         Integer it = i;

         String str2 = it.toString();

2.字符串转数字

调用Integer的静态方法parseInt

         String str = "999" ;

         

         int i= Integer.parseInt(str);

         

         System.out.println(i);

数学方法

java.lang.Math提供了一些常用的数学运算方法，并且都是以静态方法的形式存在

四舍五入, 随机数，开方，次方，π，自然常数

         float f1 = 5 .4f;

         float f2 = 5 .5f;

         //5.4四舍五入即5

         System.out.println(Math.round(f1));

         //5.5四舍五入即6

         System.out.println(Math.round(f2));

         

         //得到一个0-1之间的随机浮点数（取不到1）

         System.out.println(Math.random());

         

         //得到一个0-10之间的随机整数 （取不到10）

         System.out.println(( int )( Math.random()* 10 ));

         //开方

         System.out.println(Math.sqrt( 9 ));

         //次方（2的4次方）

         System.out.println(Math.pow( 2 , 4 ));

         

         //π

         System.out.println(Math.PI);

         

         //自然常数

         System.out.println(Math.E);

练习：

统计找出一千万以内，一共有多少质数

质数概念: 只能被1和自己整除的数
举例:
5只能被 1和5整除，所以是质数
8可以被2整除，所以不是质数

格式化输出

1.格式化输出

如果不使用格式化输出，就需要进行字符串连接，如果变量比较多，拼接就会显得繁琐
使用格式化输出，就可以简洁明了

%s 表示字符串
%d 表示数字
%n 表示换行

         String name = "盖伦" ;

         int kill = 8 ;

         String title= "超神" ;

         

         //直接使用+进行字符串连接，编码感觉会比较繁琐，并且维护性差,易读性差

         String sentence = name+ " 在进行了连续 " + kill + " 次击杀后，获得了 " + title + " 的称号" ;

         

         System.out.println(sentence);

         

         //使用格式化输出

         //%s表示字符串，%d表示数字,%n表示换行

         String sentenceFormat = "%s 在进行了连续 %d 次击杀后，获得了 %s 的称号%n" ;

         System.out.printf(sentenceFormat,name,kill,title);

2.printf和format

printf和format能够达到一模一样的效果， 通过eclipse查看java源代码 可以看到，在printf中直接调用了format

3.换行符

换行符就是另起一行 --- '\n' 换行（newline）
回车符就是回到一行的开头 --- '\r' 回车（return）
在eclipse里敲一个回车，实际上是 回车换行符
Java是跨平台的编程语言，同样的代码，可以在不同的平台使用，比如Windows,Linux,Mac
然而在不同的操作系统，换行符是不一样的
（1）在DOS和Windows中，每行结尾是 “\r\n”；
（2）Linux系统里，每行结尾只有 “\n”；
（3）Mac系统里，每行结尾是只有 "\r"。
为了使得同一个java程序的换行符在所有的操作系统中都有一样的表现，使用%n，就可以做到平台无关的换行

4.总长度，左对齐，补0，千位分隔符，小数点位数，本地化表达

其他常用的格式化方式

         int year = 2020 ;

         //总长度，左对齐，补0，千位分隔符，小数点位数，本地化表达

          

         //直接打印数字

         System.out.format( "%d%n" ,year);

         //总长度是8,默认右对齐

         System.out.format( "%8d%n" ,year);

         //总长度是8,左对齐

         System.out.format( "%-8d%n" ,year);

         //总长度是8,不够补0

         System.out.format( "%08d%n" ,year);

         //千位分隔符

         System.out.format( "%,8d%n" ,year* 10000 );

  

         //小数点位数

         System.out.format( "%.2f%n" ,Math.PI);

          

         //不同国家的千位分隔符

         System.out.format(Locale.FRANCE, "%,.2f%n" ,Math.PI* 10000 );

         System.out.format(Locale.US, "%,.2f%n" ,Math.PI* 10000 );

         System.out.format(Locale.UK, "%,.2f%n" ,Math.PI* 10000 );

          

字符

1.保存一个字符的时候用char

字母、字符、汉字

2.char对应的封装类

char对应的封装类是Character

3.Character常见方法

         System.out.println(Character.isLetter( 'a' )); //判断是否为字母

         System.out.println(Character.isDigit( 'a' )); //判断是否为数字

         System.out.println(Character.isWhitespace( ' ' )); //是否是空白

         System.out.println(Character.isUpperCase( 'a' )); //是否是大写

         System.out.println(Character.isLowerCase( 'a' )); //是否是小写

         

         System.out.println(Character.toUpperCase( 'a' )); //转换为大写

         System.out.println(Character.toLowerCase( 'A' )); //转换为小写

 

         String a = 'a' ; //不能够直接把一个字符转换成字符串

         String a2 = Character.toString( 'a' ); //转换为字符串

4.常见转义

         System.out.println( "使用空格无法达到对齐的效果" );

         System.out.println( "abc def" );

         System.out.println( "ab def" );

         System.out.println( "a def" );

          

         System.out.println( "使用\\t制表符可以达到对齐的效果" );

         System.out.println( "abc\tdef" );

         System.out.println( "ab\tdef" );

         System.out.println( "a\tdef" );

         

         System.out.println( "一个\\t制表符长度是8" );

         System.out.println( "12345678def" );

          

         System.out.println( "换行符 \\n" );

         System.out.println( "abc\ndef" );

 

         System.out.println( "单引号 \\'" );

         System.out.println( "abc\'def" );

         System.out.println( "双引号 \\\"" );

         System.out.println( "abc\"def" );

         System.out.println( "反斜杠本身 \\" );

         System.out.println( "abc\\def" );

字符串

1.创建字符串

字符串即字符的组合，在Java中，字符串是一个类，所以我们见到的字符串都是对象 
常见创建字符串手段： 
1. 每当有一个 字面值出现的时候，虚拟机就会创建一个字符串 
2. 调用String的构造方法创建一个字符串对象 
3. 通过+加号进行字符串拼接也会创建新的字符串对象 

2.final

String 被修饰为final,所以是不能被继承的

3.immutable  

immutable 是指不可改变的
比如创建了一个字符串对象
String garen ="盖伦";
不可改变的具体含义是指：
不能增加长度
不能减少长度
不能插入字符
不能删除字符
不能修改字符
一旦创建好这个字符串，里面的内容  永远 不能改变

String 的表现就像是一个 常量

4.字符串格式化

如果不使用字符串格式化，就需要进行字符串连接，如果变量比较多，拼接就会显得繁琐 
使用 字符串格式化 ，就可以 简洁明了  
更多的格式化规则，参考 格式化输出

5.字符串长度

length方法返回当前字符串的长度 
可以有长度为0的字符串,既空字符串

练习：

（1）随机字符串

创建一个长度是5的随机字符串，随机字符有可能是数字，大写字母或者小写字母

给点提示: 数字和字符之间可以通过互相转换

char c = 'A';

short s = (short) c;

通过这个手段就能够知道字符 a-z A-Z 0-9 所对应的数字的区间了

需要用到 ASCII码对照表

（2）字符串数组排序

创建一个长度是8的字符串数组
使用8个长度是5的随机字符串初始化这个数组
对这个数组进行排序，按照每个字符串的首字母排序(无视大小写)

注1： 不能使用Arrays.sort() 要自己写
注2： 无视大小写，即 Axxxx 和 axxxxx 没有先后顺序

（3 ）穷举法破解密码

1. 生成一个长度是3的随机字符串，把这个字符串作为当做密码

2. 使用穷举法生成长度是3个字符串，匹配上述生成的密码

要求： 分别使用多层for循环 和 递归解决上述问题

操纵字符串

1.获取字符

charAt(int index)获取指定位置的字符

2.获取对应的字符数组

toCharArray()
获取对应的字符数组

3.截取字符串

subString 
截取子字符串

4.分隔

split 
根据分隔符进行分隔

5.去掉收尾空格

trim 
去掉首尾空格

6.大小写

toLowerCase 全部变成小写 
toUpperCase 全部变成大写

7.定位

indexOf 判断字符或者子字符串出现的位置
contains 是否包含子字符串

8.替换

replaceAll 替换所有的 
replaceFirst 只替换第一个

练习......

每个单词的首字母都转换成大写

英文绕口令

间隔大写小写模式

最后一个字母变大写

把最后一个two单词首字母大写

比较字符串

1.是否是同一个对象

str1和str2的内容一定是一样的！ 
但是，并不是同一个字符串对象

         String str1 = "the light" ;

         

         String str2 = new String(str1);

         

         //==用于判断是否是同一个字符串对象

         System.out.println( str1  ==  str2);

2.是否是同一个对象（特例 ）

str1 = "the light";

str3 = "the light";

一般说来，编译器每碰到一个字符串的字面值，就会创建一个新的对象
所以在第str1行会创建了一个新的字符串"the light"
但是在第str3行，编译器发现已经存在现成的"the light"，那么就直接拿来使用，而没有进行重复创建

         String str1 = "the light" ;

         String str3 = "the light" ;

         System.out.println( str1  ==  str3);

3.内容是否相同

使用equals进行字符串内容的比较，必须大小写一致 
equalsIgnoreCase，忽略大小写判断内容是否一致

4.是否以子字符串开始或者结束

startsWith //以...开始

endsWith //以...结束

练习： 比较字符串

创建一个长度是100的字符串数组

使用长度是2的随机字符填充该字符串数组

统计这个字符串数组里 重复的字符串有多少种

StringBuffer

StringBuffer是可变长的字符串

1.追加 删除 插入 反转

append追加 
delete 删除 
insert 插入 
reverse 反转

2.长度 容量

为什么StringBuffer可以变长？ 
和String内部是一个字符数组一样，StringBuffer也维护了一个字符数组。 但是，这个字符数组，留有冗余长度 
比如说new StringBuffer("the")，其内部的字符数组的长度，是19，而不是3，这样调用插入和追加，在现成的数组的基础上就可以完成了。 
如果追加的长度超过了19，就会分配一个新的数组，长度比原来多一些，把原来的数据复制到新的数组中，看上去 数组长度就变长了 参考MyStringBuffer 
length: “the”的长度 3 
capacity: 分配的总空间 19

练习：

（1）StringBuffer 性能

String与StringBuffer的性能区别?

生成10位长度的随机字符串
然后,先使用String的+,连接10000个随机字符串,计算消耗的时间
然后,再使用StringBuffer连接10000个随机字符串,计算消耗的时间

提示: 使用System.currentTimeMillis() 获取当前时间(毫秒)

（2）MyStringBuffer

根据接口IStringBuffer ，自己做一个MyStringBuffer

MyStringBuffer

1.IStringBuffer接口

public interface IStringBuffer {

     public void append(String str); //追加字符串

     public void append( char c);  //追加字符

     public void insert( int pos, char b); //指定位置插入字符

     public void insert( int pos,String b); //指定位置插入字符串

     public void delete( int start); //从开始位置删除剩下的

     public void delete( int start, int end); //从开始位置删除结束位置-1

     public void reverse(); //反转

     public int length(); //返回长度

}

2.value和capacity

value：用于存放字符数组
capacity： 容量
无参构造方法： 根据容量初始化value

public MyStringBuffer(){

value = new char[capacity];

}

3.带参构造方法

4.反转

5.插入insert和append

边界条件判断
插入之前，首先要判断的是一些边界条件。 比如插入位置是否合法，插入的字符串是否为空

扩容
1. 要判断是否需要扩容。 如果插入的字符串加上已经存在的内容的总长度超过了容量，那么就需要扩容。
2. 数组的长度是固定的，不能改变的，数组本身不支持扩容。 我们使用变通的方式来解决这个问题。
3. 根据需要插入的字符串的长度和已经存在的内容的长度，计算出一个新的容量。 然后根据这个容量，创建一个新的数组，接着把原来的数组的内容，复制到这个新的数组中来。并且让value这个引用，指向新的数组，从而达到扩容的效果。

插入字符串
1. 找到要插入字符串的位置，从这个位置开始，把原数据看着两段，把后半段向后挪动一个距离，这个距离刚好是插入字符串的长度
2. 然后把要插入的数据，插入这个挪出来的，刚刚好的位置里。

修改length的值
最后修改length的值，是原来的值加上插入字符串的长度

insert(int, char)
参数是字符的insert方法，通过调用insert(int, String) 也就实现了。

append
追加，就是在最后位置插入。 所以不需要单独开发方法，直接调用insert方法，就能达到最后位置插入的效果

6.删除 delete

练习：性能比较

以上来源：数字与字符串