String方法以及区别

今天学习了字符串中string以及stringbuffer和stringbuilder的区别，还有伪随机数Random（没有真正意义上的随机数）

字符串（）

字符串实际属于类，实际上所谓的字符串就是指一组字符的有序序列,可以使用双引号进行定义，属于复杂类型

String s1="asdfsafd";  字符串
char c='a'  字符类型

字符串指的是字符的序列，有两种类型的字符串，可以使用3个不同的类进行定义

• 一种是创建以后不需要改变的，称为字符串常量，在Java中，String类用于存储和处理字符串常量
• 另外一种字符串是创建以后，需要对其进行改变的，称为字符串变量，在Java中
  StringBuilder/StringBuffer类用于存储和操作字符串变量
• 字符串有长度限制，在编译期要求字符串常量池中的常量不能超过65535，并且在javac执行过程中控制了最大值为65534。在运行期，长度不能超过Int的范围，否则会抛异常。

String类型字串

字符串在Java中以String类别的一个实例存在

• 不可变immutable字符串。含义是一个字符串对象一旦被配置，它的内容就是固定不可变的，如果需要进行修改则会引发对象的新建。

创建字串对象

 new String（）空的字符串常量，例如String s=new String();
   new String（String value）,例如Strings=new String(“abcd”);
   new String（char value[]）例如char[] c=new char[]{‘a’,’b’};String s=new
String(c);实际上就是创建一个字符串”ab”
   new String（StringBuffer buffer）

字串的使用

• 字符串必须使用“”来包括您的文字,在Java中单双引号具有不同的含义，特别注意
• 字符串的字符是使用Unicode字符来建构
• 字符串的串接在Java中可以直接使用’+/+=’，安装规则不允许重新定义运算符,但是Java重新定义了两个运算符

字符串方法

• length()取得字符串的字符长度

String ss="abc中国";
 System.out.println(ss.length());//5
在Java中所使用的编码字符集为Unicode

• equals()判断原字符串中的字符是否相等于指定字符串中的字符。重点在于equals和==的区别
• toUpperCase() 转换字符串中的英文字符为大写

String s1 = "a sdfa123sd,f";
StringBuilder sb = new StringBuilder();
for (int i = 0; i < s1.length(); i++) {
 char temp = s1.charAt(i);
 if (temp >= 'a' && temp <= 'z') {
 char tt = (char) (temp - 32);
 sb.append(tt);//在sb的末尾追加字符
 }else
 sb.append(temp);
}
System.out.println(sb);

• toLowerCase() 转换字符串中的英文字符为小写
• 对已有字串进行反转操作

String s1 = "asdfasdf";
StringBuilder sb=new StringBuilder();
for(int i=s1.length()-1;i>=0;i--)
 sb.append(s1.charAt(i));
System.out.println(sb);

将输入的字符串转换为整数、浮点数等

double dd=Double.parseDouble("12.34");/valueOf
 Integer.parseInt()  Short.parseShort  Booealn.parseBoolean...
    有可能会出现转换失败情形，报错并中断程序的允许[鲁棒性差]

""+double

字符串中子串的查找与字符串中单个字符的查找相似

• int indexOf（String str）从左向右开始查找str的起始下标，如果找到了则返回str起始位置的下
  标，如果查找不到则返回-1
• int indexOf（String str,int fromIndex）从指定下标位置fromInde开始左向右查找str的下标

 String ss="System.out.println(s1.compareTo(s2));";
int pos=ss.indexOf("outw");
System.out.println(pos);

要求输出所有.的下标位置

String ss = "System.out.println(s1.compareTo(s2));";
int pos = ss.indexOf(".");
int k = 0;
while (pos > -1) {
 System.out.println("第" + (++k) + "次出现的位置为:" + pos);
 pos=ss.indexOf(".",pos+1);
}

• int lastIndexOf（String str）从右向左开始查找str的起始下标
• int lastIndexOf（String str, int fromIndex）从指定下标位置fromInde开始右向左查找str的下标

 查找最👉有一个点的出现位置
int pos=ss.lastIndexOf(".")

• endsWith(“str”):boolean 判断字串是否以str为结尾
• boolean startsWith（String ）判断字串是否以string为开头
• char charAt(int index)获取指定下标index位置上的字符
• char[ ] toCharArray()将字串转换为char数组

字符串中字符的替换String replace（char oldChar, char newChar）将字串中指定的字符oldChar转换为新的字符newChar，并返回替换后的结果

String s2=ss.replace(".", "111");  将字符串ss中的字串.转为111
统计点出现的次数
String ss = "System.out.println(s1.compareTo(s2));";
String s2 = ss.replace(".", "");
System.out.println((ss.length() - s2.length()) / ".".length());

• String replaceFirst（String regex, String replacement）用字符串replacement的内容替换当前字
  符串中遇到的第一个和字符串regex相一致的子串，并将产生的新字符串返回
• String replaceAll（String regex, String replacement）用字符串replacement的内容替换当前字
  符串中遇到的所有和字符串regex相一致的子串，并将产生的新字符串返回

做几个练习巩固上面的方法使用

练习题

1、获取指定字符串asdkbfasldkbnv,cnvzxnkbjfdfkd中kd的出现次数

String ss = "asdkbfasldkbnv,cnvzxnkbjfdfkd";
String s2 = ss.replace("kd", "");
System.out.println((ss.length() - s2.length()) / "kd".length());

2、输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数

使用数组存放出现次数：int[] times=new int[4]; 0-英文1-空格2-数字3其它
Scanner sc = new Scanner(System.in);
while (true) {
 System.out.println("请输入一行字符，以回车结束,输入quit则退出程序");
 String ss = sc.nextLine();
 if("quit".equals(ss)) break;
 int[] arr = new int[4];
 for (int i = 0; i < ss.length(); i++) {
 char c = ss.charAt(i);
 if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
 arr[0]++;
 else if (c == ' ')
 arr[1]++;
 else if (c >= '0' && c <= '9')
 arr[2]++;
 else
 arr[3]++;
 }
 System.out.printf("英文字母出现次数为%d,空格出现次数为%d,数字出现次数为%d,其它
字符出现次数为%d", arr[0], arr[1], arr[2], arr[3]);
}

• 判断中文具体的匹配中文及字符方法：/[\u4E00-\u9FA5\uF900-\uFA2D]/

3、将整数转换为大写的汉字，例如1234转换为壹仟贰佰叁拾肆元

int kk=123456;
StringBuilder sb=new StringBuilder();
char[] ns=new char[]{'零','壹','贰','叁','肆','伍','陆','柒','捌','玖'};
char[] us=new char[]{'圆','拾','佰','仟','萬','拾'};
String ss=""+kk;
for(int i=0;i<ss.length();i++){
 char temp=ns[ss.charAt(i)-'0'];
 sb.append(temp); }
int k=0;
for(int i=ss.length()-1;i>=0;i--){
 sb.insert(i+1,us[k++]); }
System.out.println(sb.toString());

substring用于实现截取字串中的部分内容

• substring(int起始下标):String 获取字符串中从起始下标开始到字串末尾的所有字符
• substring(int起始下标，int终止下标):String获取字符串中指定下标之间的内容，含左不含右

- String abc="sdf,sad,fsafd,safsd";
//先获取逗号出现的次数从而确定字串可以分的段数
String ss=abc.replace(",","");
int num=abc.length()-ss.length();获取逗号的出现次数
String[] arr=new String[++num];初始化存储子字串的数组
int begin=0;
int index=abc.indexOf(",");查看第一次逗号出现的位置
int k=0;
while(index>-1){如果查找到逗号
arr[k++]=abc.substring(begin,index);截取部分内容
begin=index+1;
index=abc.indexOf(",",begin); }
if(begin<abc.length())补偿最后逗号不出现
arr[k]=abc.substring(begin);
for(String temp:arr)
System.out.println(temp);

split(“正则式”):String[] 可以按照指定的正则式条件分割字串返回分割后生成的数组

String abc="sdf,sad,fsafd,safsd";
String[] arr=abc.split(",");按照逗号作为分割符分割字符串
for(String temp:arr)
 System.out.println(temp);

• trim():String去除字符串两端的空格，无论多少个空格

StringBuffer 和 StringBuilder 类

• String类型的变量进行修改操作时一定会引发对象的新建
  -------在java中所有的复杂类型变量中都会有一个方法hashCode():int，这个值是一个和变量存储位置相关的数据
  -------对象的创建和销毁是需要时间代价的
• 使用StringBuffer和StringBuilder类的前提是频繁的修改操作
• 和String类不同的是，StringBuffer和StringBuilder类的对象能够被多次的修改且不产生新的未使用对象。StringBuilder类在Java 5中被提出，它和StringBuffer间的最大不同在于StringBuilder的方法不是线程安全的（不能同步访问）。由于StringBuilder相较于StringBuffer有速度优势，所以多数情况下建议使用StringBuilder类。然而在应用程序要求线程安全的情况下，则必须使用StringBuffer类。

Random类

Random类中实现的随机算法是伪随机（创建对象
new Random）

Random类中的常用方法

• boolean nextBoolean()方法的作用是生成一个随机的boolean值，生成true和false的值几率相等，也就是都是50%的几率
• double nextDouble()方法的作用是生成一个随机的double值，数值介于[0,1.0)之间
• int nextInt()该方法的作用是生成一个随机的int值，该值介于int的区间，也就是2e9之间
• int nextInt(int n)方法的作用是生成一个随机的int值，该值介于[0,n)的区间，也就是0到n之间的随机int值，包含0而不包含n**
• void setSeed(long seed)方法的作用是重新设置Random对象中的种子数。设置完种子数以后的Random对象和相同种子数使用new关键字创建出的Random对象相同

 Random r = new Random();
int kk=r.nextInt();
System.out.println(kk);

生成随机的字符值

Random r = new Random();
int kk=r.nextInt(26);
System.out.println((char)('a'+kk));

摇号器

public static boolean exists(int[] arr,int num){
 boolean res=false;
 for(int i=0;i<arr.length;i++){
 if(num==arr[i]){
 res=true;
            break;
       }
 }
 return res；
 }
 //超级大乐透,取值1-36,不重复
public static void main(String[] args) {
 int[] res=new int[7];
 Random r=new Random();
 int i=0;
 while(i<=6){
 int temp=r.nextInt(36)+1;
 boolean rb=exists(res, temp);
 if(!rb) res[i++]=temp; }
 for(int temp:res)
 System.out.println(temp); }

（注意：一般开发中不使用随机种子值，因为系统默认使用的是系统的当前时间作为种子值。

例题：

生成长度在1-10个字符以内，内容为[a-zA-Z]的随机长度的随机字符串：

public static String generateString() {
 String source = "abcdefghijkmnpqrstuvwxyzQWERTYUIOPASDFGHJKLZXCVBNM";
 Random r = new Random();
 int cc = r.nextInt(10) + 1;
 StringBuilder sb=new StringBuilder();
 for (int i = 0; i < cc; i++) {
 int randomIndex=r.nextInt(source.length());
 char temp=source.charAt(randomIndex);
 sb.append(temp); }
 return sb.toString(); }
public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 while (true) {
     System.out.println("点q键退出，否则生成下一字符串");
 String str = sc.nextLine();
 if ("q".equals(str.trim())) break;
 else System.out.println(generateString()); }
}