java基础-API-String类、基本数据类型对象包装类

/*
1、模拟一个trim方法,去除字符串两端的空格。
思路：
1,判断字符串第一个位置是否是空格,如果是继续向下判断,直到不是空格为止。
结尾处判断空格也是如此。
2,当开始和结尾都判断不是空格时,就是要获取的字符串。
 
2、将一个字符串进行反转。将字符串中指定部分进行反转,“abcdefg”;abfedcg
思路：
1,曾经学习过对数组的元素进行反转。
2,将字符串变成数组,对数组进行反转。
3,将反转后的数组变成字符串。
4,只要将要反转的部分的开始和结束位置作为参数传递即可。
 
3、获取一个字符串在另一个字符串中出现的次数。
“abkkcdkkefkkskk”
思路：
1,定义个计数器。
2,获取kk第一次出现的位置。
3,从第一次出现位置后剩余的字符串中继续获取kk出现的位置。
每获取一次就计数一次。
4,当获取不到时,计数完成。
 
4、获取两个字符串中最大相同子串。第一个动作：将短的那个串进行长度依次递减的子串打印。
“abcwerthelloyuiodef”
"cvhellobnm"
思路：
1,将短的那个子串按照长度递减的方式获取到。
2,将每获取到的子串去长度中判断是否包含。如果包含,已经找到！
*/
 
class  StringTest
{
public static void main(String[] args) 
{
String s = "   ab  cd   ";
        sop(myTrim(s));
String s1 = "abcdef";
sop(myReverse(s1));
String s2 = "abkkcdkkefkkskk";
sop(getSubCount(s2,"kk"));
String s3 ="abcwerthelloyuiodef",s4="cvhellobnm";
sop(getMaxString(s3,s4));
}
 
 
//1、模拟一个trim方法,去除字符串两端的空格。
public static String myTrim(String str)
{
int start = 0, end = str.length()-1;
 
while(startstart++;
while(startend--;
return str.substring(start,end+1);
 
}

//2、将一个字符串进行反转。将字符串中指定部分进行反转,“abcdefg”;abfedcg
 
 
public static String myReverse(String s)
{
return myReverse(s,0,s.length()-1);
}
 
public static String myReverse(String s,int start,int end)
{
char[] ch = s.toCharArray();
reverse(ch,start,end);
return new String(ch);
}
private static void reverse(char[] arr,int x,int y)
{
for (int start=x,end=y; start{
swap(arr,start,end);
}
}
private static void swap(char[] arr,int x,int y)
{
char temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
 }
 
//3、获取一个字符串在另一个字符串中出现的次数。“abkkcdkkefkkskk”
public static int getSubCount(String s,String key)
{
int count = 0;
int index = 0;
while((index=s.indexOf(key,index))!=-1)
{
count++;
index+=key.length();
}
return count;
}
 
//  4、获取两个字符串中最大相同子串。
 
public static String getMaxString(String s1,String s2)
{
String max = (s1.length()>s2.length())?s1:s2;
String min = (max==s1)?s2:s1;
for (int x=0; x{
for (int y=0,z=min.length()-x; z!=min.length()+1; y++,z++)
{
String temp = min.substring(y,z);
if(max.contains(temp))
return temp;
}
}
return "";
}
 
public static void sop(Object obj)
{
System.out.println(obj);
}
}

class IntegerDemo1 
{
public static void main(String[] args) 
{
//Integer x = new Integer(4);
Integer x = 4;//自动装箱。等同于new Integer(4)
x = x + 2;//x+2:x 进行自动拆箱x.intValue()。变成了int类型，和2进行加法运算。
  //再将和进行装箱赋给x。

Integer m = 128;
Integer n = 128;
sop(m==n);//false
 
Integer a = 128;
Integer b = 128;
sop(a==b);//true 因为a和b指向了同一个Integer对象。
  //对于新特性，当数值在byte范围内时，如果该数值已经存在，则不会再开辟新的空间。

} 
public static void method()
{
Integer x = new Integer("123");
Integer y = new Integer(123);
 
sop(x==y);//false
sop(x.equals(y));//true
}
 
public static void sop(Object obj)
{
System.out.println(obj);
}
}

import java.util.*;
import java.util.Scanner;
/*
对一个字符串中的数值进行从小到大的排序。
“20 78 9 -7 88 36 29”
*/
class StringSort   
{
public static void main(String[] args) 
{
String s = "20 78 9 -7 88 36 29";
sop(s);
s = sortString(s);
sop(s);
}
 
public static String sortString(String s)
{
//将字符串变成字符串数组。
String[] str_arr = stringToArray(s);
 
//将字符串数组变成int数组。
int[] int_arr = toIntArray(str_arr);
 
//对int数组排序。
mySortArray(int_arr);
 
//将排序后的数组变成字符串。
String temp = arrayToString(int_arr);
 
return temp;
}
 
public static String[] stringToArray(String s)
{
String[] arr = s.split(" ");
return arr;
}
 
public static int[] toIntArray(String[] str_arr)
{
int[] arr = new int[str_arr.length];
for (int i=0; i{
arr[i] = Integer.parseInt(str_arr[i]);
}
return arr;
}
 
public static void mySortArray(int[] int_arr)
{
Arrays.sort(int_arr);
}
 
public static String arrayToString(int[] int_arr)
{
StringBuilder sb = new StringBuilder();
for (int x=0; x{
if (x!=int_arr.length-1)
sb.append(int_arr[x]+" ");
else
sb.append(int_arr[x]);
}
return sb.toString();
}

public static void sop(Object obj)
{
System.out.println(obj);
}
}