javase_10(String类日常操作)

package com.javami.kudy.javaapi1.StringStudy;

public class StringDemo {
/*面试题：
* 1.Stirng s = "abc" String s = new String("abc"); //有什么区别?
* 2.String s = new String("abc"); 创建了几个对象 2个(池里没有)或1个(池里有了)，
* 3.String s = "a" + "b" + "c" + "d"; 创建了几个对象？ 创建了1个对象
* 4.String s1 = "a"; String s2 = "b"; String s3 = s1 + s2;  s3=="ab"?
*/

public static void main(String[]args)
{
/*
* 1.String池,由于字符串操作很频繁.java针对String对象提供了缓冲池
* s1首先会在缓冲池里面看一下有没有"abc" 如果没有的.那么把对象创建的引用返回给s1
* 当s2开始执行.会检查缓冲池里面有没有.如果有的.直接把对象的地址返回给s2 .所以是相等的.。
String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2);
*/

/*
String s1 = "abc";
String s2 = new String(s1);
outcome ： false
s2在堆内存中创建了一个对象(把地址返回来~),并且在堆内存里面的缓冲池里面创建一个"abc"(这个是对象里面的一个拷贝副本)
做java的日常维护.所以那么这两个地址一比较.就会不相等..
*/

/*
String s1 = "a"+"b"+"c";
String s2 ="abc";
outCome = "true";
因为java编译器有个合并已知量的功能,在编译阶段"a"+"b"+"c" 合并为"abc"并且保存在缓冲池里面
所以s2在检测缓冲池里面.检测到已经有了.直接把对象的引用所返回来.那么证明了s1  s2 是同一个地址/所以比较出来为true
*/

/*
String s1 = new String("abc");
String s2 = new String("abc");
这两个里面创建了多少个对象呢?
解答：  首先会在堆内存中创建一个对象.在检测池里面有没有,没有也在了缓冲池里面创建了一个.做日常的维护
s2也会在堆内存中创建一个对象.这时候检测到池里面已经有了.所以就不再创建/
说百了也就是3个..
一般面试简单的就直接说：2个就可以.
*/

/*
* String 是一个常量,是不能改变的量
* 内部实现：
* StringBuilder sb = new StringBuilder(s1);
* sb.append(s2);
* s3 = sb.toString(); //转换回字符串
* 返回调用方法的都是创建一个对象的
*
*/
String s1 = "a";
String s2 = "b";
String s3 = s1 + s2;
System.out.println(s3=="ab"); //直接返回一个flase

}

}

package com.javami.kudy.javaapi1.StringStudy;

import java.io.UnsupportedEncodingException;

public class DecodeTest {

/*
* 解码： 用错误的码再变回来.然后用正确的编码方式就可以
* 编码错误： 没办法,神仙也救不了
*/
public static void main(String[]args) throws UnsupportedEncodingException
{
String str1 = "中国人";  //使用gb2312编码
// 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
byte[] newbyte = str1.getBytes();

String str2 = new String(newbyte);
System.out.println(str2);

String str3 = new String(newbyte,"iso-8859-1");
//System.out.println(str3);编码的信息出错
newbyte = str3.getBytes("iso-8859-1");
String str4 = new String(newbyte);
System.out.println(str4);

byte[]new1 = str1.getBytes("iso-8859-1");
//一开始编码的信息就出错!因为我的计算机根本就没有这个编码
String s6 = new String(new1);
new1 = s6.getBytes("iso-8859-1");
String st7 = new String(new1);
System.out.println(st7);
}
}

package com.javami.kudy.javaapi1.StringStudy;

public class StringTest {
/*String 为什么要重写toString()方法呢?
解答：因为在String如果不重写Object的toString方法.那么直接复用父类的方法.打印出的是对象.
这显然不是String想要得到的结果
*/
public static void main(String[]args)
{
String s1 = "kudy";
System.out.println(s1.charAt(3)); //索引是从零开始\
String s2 ="abcde";
String s3 = "aBcddddd";
System.out.println(s2.compareToIgnoreCase(s3));

String s4 = "abc";
String s5 = "def";
System.out.println((s4.concat(s5)).toString());

boolean is = s4.contains(s5);
System.out.println(is);

String fileName = "Demo.jdk";
if(fileName.endsWith(".java"))
System.out.println("您是java文件");

String s6 = "cnabcdbvklabcjdhfabcdhla";
int newint = s6.indexOf("abc",0);  //注意：索引是从零开始
System.out.println(newint);

String s7 = "abc";
String s8 = new String("abc");
s8.intern();
System.out.println(s7 == s8);

String s9 = "cascascacvdfdjkgksd";
int num = s9.lastIndexOf("k",s9.length()-1);
System.out.println(num);

String s10 = "abc";
String s11 = s10.replace("abc","***");
System.out.println(s11);

String s12 = "hello.java";
String s13 = s12.replace("java","jdk" );
System.out.println(s13);

/*
* 把有逗号的内容去掉。
*/
String s14 = "ab,cd,ef";
String [] s15 = s14.split(",");
for(String num1 : s15)
System.out.print(num1);

String s16 = "abcbsbdasdas";
char[] newchar = s16.toCharArray();
for(char num2 : newchar)
System.out.print(num2);
System.out.println();

/*
* 但注意中间的是不能去掉的~~
*/
String s17 = "   abc      def     ";
String s18 = s17.trim();
System.out.println(s18);
}
}

package com.javami.kudy.javaapi1.StringStudy;

import java.io.IOException;

public class StringUtil {
private StringUtil(){} //私有化

/* 查找子字符串在字符串中出现的位置 例：“ab”在"habjklabljhlabhjdjfla"出现的位置为：1 6  12
* 思路：
* 1.定义一个StringBuilder容器，用于存储位置，定义一个pos变量记住出现的位置，初始值为0
* 2.定义一个while循环，查找子串出现的位置
* 3.调用indexOf方法，从起始位置开始查找出子串首次出现的位置
* 4.如果pos为-1，说明没找到，应该结束循环
* 5.将位置存入StringBuilder容器，再加一个逗号分隔
* 6.从找到的位置加上子串的长度作为新的起始位置，
* 7.循环结束，将StringBuffer转为String字符串，调用split方法以逗号进行分隔，获得了String数组
* 8.准备一个新的int数组，长度和String数组一样，遍历String数组，将每个元素转为int存入int数组
*/
public static int[]findIndexOfSubstr(String str, String substr)
{
StringBuilder sb = new StringBuilder();
int pos = 0;
while(true)
{
pos = str.indexOf(substr,pos);
if(pos ==-1)
break;
sb.append(pos+",");
pos+=substr.length(); //pos假设找ab 找到1 + 2 等于三.刚好从第三个开始找~
}
if(sb.length() == 0) //容器什么都没有！
return null;  //一个都找不到
String s = sb.toString(); //转换成字符串形式
String[] parts = s.split(",");
int[] arr = new int[parts.length];
for(int i=0; i<parts.length; i++)
{
arr[i] = Integer.parseInt(parts[i]);
}
return arr;
}

/*
* 设计一个方法，读取键盘输入的一行（只支持英文字母）
* 提示：System.in.read()读取键盘上的一个字符
* 思路：
* 1.定义一个容器StringBuilder容器
* 2.定义一个while循环,循环读取键盘.
* 3.如果读到回车或者\n 就跳出循环
* 4.存入StringBuilfer容器中
* 5.循环结束,返回一个toString转换为字符串
*/
public static String readLine() throws IOException
{
StringBuilder sb = new StringBuilder();
while(true)
{
int ch = System.in.read();
if(ch == '\r')  //如果回车 跳出去
continue;
if(ch == '\n')  //等上面的执行完毕.再来
break;
sb.append((char)ch);
}
return sb.toString(); //转换成字符串
}

/*
* *将给定的字节数组截取一部分，进行解码，要求输出完整的汉字，例如："abc中国人"截取6个 输出的是abc中
* 思路：
*     1.遍历数组被截取的部分,
* 2.判断正负数，统计负数个数为count
* 3.判断count的奇偶，奇数减去1，偶数不变
* 4.解码
* 汉字是占了2个字节?我们怎么判断它是汉字呢?
* 汉字的第一位字节保证是负数!第二个是正数
*
*/
public static String decode(byte[]buf, int len)
{
int count = 0;
for(int i=0; i<buf.length;i++)
if(buf[i]<0)
count++; //如果第一个字节是负数的.是代表汉字马上来到.咱们+1
if(count % 2 == 1)
len--;
return new String(buf,0,len);
/*程序流程图： 咱们输入一个buf   len = 5
* for 执行5次
* 因为一个汉字是占了2个字节.而第一个字节保证是负数
* 如果 buf[i]里面的是负数的 count +1 = 1
* 如果   % 2  等于1代表的是：   咱们len 传递进来的就减去一个字节.
*
*/
}

public static String decodeBYGBK(byte[]buf,int len)
{
boolean b = false;
for(int i=0; i<buf.length; i++)
if(b)
b = false;
else if(buf[i]<0)
b = true;
if(b)
len --;
return new String(buf,0,len);

}

/*
* 查找一个字符串出现次数最多的字符     abvjdabahabballfja   出现次数最多的为:a  6
* 思路：
* 1.调用toCharArray字符串把字符串转换成字符数组
* 2.定义max，用于记住出现最多字符的次数，定义一个maxChar记住出现最多的字符
* 3.定义一个循环，每次循环都统计一个字符出现最多的次数，每次让次数和max比.谁最大就换,结束条件。当长度的数组
* 为零
* 4.定义一个count，记住本次统计字符的次数
* 5.循环遍历数组，统计第一个字符出现的次数
* 6.让次数和max比，如果max大，让max记住它的次数，让maxchar记住当前的字符
* 7.将当前的字符从数组中删除
* ------
* 将此字符串转换为一个新的字符数组。
*/

public static char searchMaxChar(String str)
{
char[] buf = str.toCharArray();
int max = 0;
char maxChar = 0;
while(buf.length>0)
{
int count = 0; //个数等于0
char firstChar = buf[0];
for(char c : buf)
if(c ==firstChar)
count++;
if(count>max) //max 已经是默认记住上一个的值！
{
max = count;
maxChar = firstChar; //如果你是最多的就让给你~~
}
//把当前的字符删除！
buf = deleteChar(buf,firstChar,count);
}
return maxChar;
}

private static char[] deleteChar(char[] buf, char firstChar, int count)
{
char[]arr = new char[buf.length-count];
int pos = 0;
for(int i=0; i<buf.length; i++)
{
if(buf[i]==firstChar)
continue;
arr[pos++] = buf[i];
}
return arr;
}
/* 查找两个字符串中的最大子串  jflwertyakjfa;l    fjdlkwertyjf;ajf 最大子串：werty
* 1.判断出两个字符串的长短，找出较长的和较短的
* 2.循环遍历较短的字符串的所有子串，由长到短遍历
*         定义一个循环，每次遍历一种长度的子串，将i作为长度，i的取值: length~1
*         定义一个内层循环，具体遍历某一种长度的子串，j做为子串的开始位置， j取值：0~length-i
*         截取子串，substring  起始位置:j  结束位置:j+i
* 3.每次变量，都判断子串是否为较长的字符串的子串，如果是，直接返回
* 4.循环结束，依然没有返回，说明没有相同子串，返回null
*/
public static String searchMaxSubStr(String s1, String s2)
{
String longStr = s1.length() > s2.length() ? s1 : s2;
String shortStr = s1.length() > s2.length() ? s2 : s1;
for(int i=shortStr.length(); i>0; i--)
{
for(int j=0;j<shortStr.length()-i+1;j++)
{
String sub = shortStr.substring(j, j+i); //例如： abcd 放到sub里面去
//abcd abc ab  a 和它里面的做一个对比
//当且仅当此字符串包含指定的 char 值序列时，返回 true。
if(longStr.contains(sub))
//判断长的字符串里面是否包含这个
return sub; //如果包含直接返回.没有包含
}
}
return null;
}
}

----------------------

package com.javami.kudy.javaapi1.StringStudy;

public class StringUtilTest {
public static void main(String[]args) throws Exception
{
/*
String str = "dsdcvcvxvczxbedfaacff";
String substr = "y";
//遍历a 出现的位置
int[]arr =  StringUtil.findIndexOfSubstr(str, substr);
if(arr ==null)
{
System.out.println("找不到！");
return ;
}
for(int num : arr)
{
System.out.print(num+" ");
}
System.out.println();

*/
/*
* 再输入byte的时候就结束,不断的去读

while(true)
{
String str2 = StringUtil.readLine();
if("bye".equals(str2))
break;
System.out.println(str2);
}
System.out.println("程序结束");
*/
byte[] buf = "abc中国人".getBytes();
//String s3 = StringUtil.decode(buf, 3);
String s3 = StringUtil.decodeBYGBK(buf, 5);
System.out.println(s3);

char maxChar = StringUtil.searchMaxChar("dasfasdfaaaaaaaasfgdagfafgsad");
System.out.println(maxChar);

String s33 = "jflwertyakjfa;l";
String s44 = "fjdlkwertyjf;ajf";
String s55 =StringUtil.searchMaxSubStr(s33,s44);
System.out.print(s55);
}

}