第一:
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);
}
}
第四:
1 package com.javami.kudy.javaapi1.StringStudy;
2
3 import java.io.IOException;
4
5 public class StringUtil {
6 private StringUtil(){} //私有化
7
8 /* 查找子字符串在字符串中出现的位置 例：“ab”在"habjklabljhlabhjdjfla"出现的位置为：1 6 12
9 * 思路：
10 * 1.定义一个StringBuilder容器，用于存储位置，定义一个pos变量记住出现的位置，初始值为0
11 * 2.定义一个while循环，查找子串出现的位置
12 * 3.调用indexOf方法，从起始位置开始查找出子串首次出现的位置
13 * 4.如果pos为-1，说明没找到，应该结束循环
14 * 5.将位置存入StringBuilder容器，再加一个逗号分隔
15 * 6.从找到的位置加上子串的长度作为新的起始位置，
16 * 7.循环结束，将StringBuffer转为String字符串，调用split方法以逗号进行分隔，获得了String数组
17 * 8.准备一个新的int数组，长度和String数组一样，遍历String数组，将每个元素转为int存入int数组
18 */
19 public static int[]findIndexOfSubstr(String str, String substr)
20 {
21 StringBuilder sb = new StringBuilder();
22 int pos = 0;
23 while(true)
24 {
25 pos = str.indexOf(substr,pos);
26 if(pos ==-1)
27 break;
28 sb.append(pos+",");
29 pos+=substr.length(); //pos假设找ab 找到1 + 2 等于三.刚好从第三个开始找~
30 }
31 if(sb.length() == 0) //容器什么都没有！
32 return null; //一个都找不到
33 String s = sb.toString(); //转换成字符串形式
34 String[] parts = s.split(",");
35 int[] arr = new int[parts.length];
36 for(int i=0; i<parts.length; i++)
37 {
38 arr[i] = Integer.parseInt(parts[i]);
39 }
40 return arr;
41 }
42
43 /*
44 * 设计一个方法，读取键盘输入的一行（只支持英文字母）
45 * 提示：System.in.read()读取键盘上的一个字符
46 * 思路：
47 * 1.定义一个容器StringBuilder容器
48 * 2.定义一个while循环,循环读取键盘.
49 * 3.如果读到回车或者\n 就跳出循环
50 * 4.存入StringBuilfer容器中
51 * 5.循环结束,返回一个toString转换为字符串
52 */
53 public static String readLine() throws IOException
54 {
55 StringBuilder sb = new StringBuilder();
56 while(true)
57 {
58 int ch = System.in.read();
59 if(ch == '\r') //如果回车 跳出去
60 continue;
61 if(ch == '\n') //等上面的执行完毕.再来
62 break;
63 sb.append((char)ch);
64 }
65 return sb.toString(); //转换成字符串
66 }
67
68 /*
69 * *将给定的字节数组截取一部分，进行解码，要求输出完整的汉字，例如："abc中国人"截取6个 输出的是abc中
70 * 思路：
71 * 1.遍历数组被截取的部分,
72 * 2.判断正负数，统计负数个数为count
73 * 3.判断count的奇偶，奇数减去1，偶数不变
74 * 4.解码
75 * 汉字是占了2个字节?我们怎么判断它是汉字呢?
76 * 汉字的第一位字节保证是负数!第二个是正数
77 *
78 */
79 public static String decode(byte[]buf, int len)
80 {
81 int count = 0;
82 for(int i=0; i<buf.length;i++)
83 if(buf[i]<0)
84 count++; //如果第一个字节是负数的.是代表汉字马上来到.咱们+1
85 if(count % 2 == 1)
86 len--;
87 return new String(buf,0,len);
88 /*程序流程图： 咱们输入一个buf len = 5
89 * for 执行5次
90 * 因为一个汉字是占了2个字节.而第一个字节保证是负数
91 * 如果 buf[i]里面的是负数的 count +1 = 1
92 * 如果 % 2 等于1代表的是： 咱们len 传递进来的就减去一个字节.
93 *
94 */
95 }
96
97 public static String decodeBYGBK(byte[]buf,int len)
98 {
99 boolean b = false;
100 for(int i=0; i<buf.length; i++)
101 if(b)
102 b = false;
103 else if(buf[i]<0)
104 b = true;
105 if(b)
106 len --;
107 return new String(buf,0,len);
108
109 }
110
111 /*
112 * 查找一个字符串出现次数最多的字符 abvjdabahabballfja 出现次数最多的为:a 6
113 * 思路：
114 * 1.调用toCharArray字符串把字符串转换成字符数组
115 * 2.定义max，用于记住出现最多字符的次数，定义一个maxChar记住出现最多的字符
116 * 3.定义一个循环，每次循环都统计一个字符出现最多的次数，每次让次数和max比.谁最大就换,结束条件。当长度的数组
117 * 为零
118 * 4.定义一个count，记住本次统计字符的次数
119 * 5.循环遍历数组，统计第一个字符出现的次数
120 * 6.让次数和max比，如果max大，让max记住它的次数，让maxchar记住当前的字符
121 * 7.将当前的字符从数组中删除
122 * ------
123 * 将此字符串转换为一个新的字符数组。
124 */
125
126 public static char searchMaxChar(String str)
127 {
128 char[] buf = str.toCharArray();
129 int max = 0;
130 char maxChar = 0;
131 while(buf.length>0)
132 {
133 int count = 0; //个数等于0
134 char firstChar = buf[0];
135 for(char c : buf)
136 if(c ==firstChar)
137 count++;
138 if(count>max) //max 已经是默认记住上一个的值！
139 {
140 max = count;
141 maxChar = firstChar; //如果你是最多的就让给你~~
142 }
143 //把当前的字符删除！
144 buf = deleteChar(buf,firstChar,count);
145 }
146 return maxChar;
147 }
148
149 private static char[] deleteChar(char[] buf, char firstChar, int count)
150 {
151 char[]arr = new char[buf.length-count];
152 int pos = 0;
153 for(int i=0; i<buf.length; i++)
154 {
155 if(buf[i]==firstChar)
156 continue;
157 arr[pos++] = buf[i];
158 }
159 return arr;
160 }
161 /* 查找两个字符串中的最大子串 jflwertyakjfa;l fjdlkwertyjf;ajf 最大子串：werty
162 * 1.判断出两个字符串的长短，找出较长的和较短的
163 * 2.循环遍历较短的字符串的所有子串，由长到短遍历
164 * 定义一个循环，每次遍历一种长度的子串，将i作为长度，i的取值: length~1
165 * 定义一个内层循环，具体遍历某一种长度的子串，j做为子串的开始位置， j取值：0~length-i
166 * 截取子串，substring 起始位置:j 结束位置:j+i
167 * 3.每次变量，都判断子串是否为较长的字符串的子串，如果是，直接返回
168 * 4.循环结束，依然没有返回，说明没有相同子串，返回null
169 */
170 public static String searchMaxSubStr(String s1, String s2)
171 {
172 String longStr = s1.length() > s2.length() ? s1 : s2;
173 String shortStr = s1.length() > s2.length() ? s2 : s1;
174 for(int i=shortStr.length(); i>0; i--)
175 {
176 for(int j=0;j<shortStr.length()-i+1;j++)
177 {
178 String sub = shortStr.substring(j, j+i); //例如： abcd 放到sub里面去
179 //abcd abc ab a 和它里面的做一个对比
180 //当且仅当此字符串包含指定的 char 值序列时，返回 true。
181 if(longStr.contains(sub))
182 //判断长的字符串里面是否包含这个
183 return sub; //如果包含直接返回.没有包含
184 }
185 }
186 return null;
187 }
188 }
189
190
191 ----------------------
192
193 package com.javami.kudy.javaapi1.StringStudy;
194
195 public class StringUtilTest {
196 public static void main(String[]args) throws Exception
197 {
198 /*
199 String str = "dsdcvcvxvczxbedfaacff";
200 String substr = "y";
201 //遍历a 出现的位置
202 int[]arr = StringUtil.findIndexOfSubstr(str, substr);
203 if(arr ==null)
204 {
205 System.out.println("找不到！");
206 return ;
207 }
208 for(int num : arr)
209 {
210 System.out.print(num+" ");
211 }
212 System.out.println();
213
214 */
215 /*
216 * 再输入byte的时候就结束,不断的去读
217
218 while(true)
219 {
220 String str2 = StringUtil.readLine();
221 if("bye".equals(str2))
222 break;
223 System.out.println(str2);
224 }
225 System.out.println("程序结束");
226 */
227 byte[] buf = "abc中国人".getBytes();
228 //String s3 = StringUtil.decode(buf, 3);
229 String s3 = StringUtil.decodeBYGBK(buf, 5);
230 System.out.println(s3);
231
232 char maxChar = StringUtil.searchMaxChar("dasfasdfaaaaaaaasfgdagfafgsad");
233 System.out.println(maxChar);
234
235 String s33 = "jflwertyakjfa;l";
236 String s44 = "fjdlkwertyjf;ajf";
237 String s55 =StringUtil.searchMaxSubStr(s33,s44);
238 System.out.print(s55);
239 }
240
241 }
posted on 2012-08-07 01:07
、小细 阅读(235)
评论(0) 编辑 收藏