Java基础--String类_string temp0 : arr1) {-CSDN博客

本文链接：https://blog.csdn.net/hi2hcs/article/details/40381097

1.String类

1.1字符串是一个特殊的对象。

1.2字符串一旦被初始化就不能被改变。
String s = "abc";//创建一个字符串对象在常量池中。		
String s1 = new String("abc");//创建一个字符串对象在堆内存中。
1.3String类中equals 覆写Object中的equals建立String类自己的判断字符串对象是否相同的依据，其实就是比较字符串的内容。

1.4String类部分方法

1.4.1,获取：

获取字符串中字符的个数(长度).

int length();

根据位置获取字符。

char charAt(int index);

根据字符获取在字符串中的第一次出现的位置.

int indexOf(int ch)

int indexOf(String str);

int indexOf(String str,int fromIndex);

int indexOf(int ch,int fromIndex):从指定位置进行ch的查找第一次出现位置

根据字符串获取在字符串中的第一次出现的位置.

int lastIndexOf(int ch)

int lastIndexOf(int ch,int fromIndex):从指定位置进行ch的查找第一次出现位置

int lastIndexOf(String str);

int lastIndexOf(String str,int fromIndex);

获取字符串中一部分字符串。也叫子串.

String substring(int beginIndex, int endIndex)//包含begin 不包含end 。

String substring(int beginIndex);

1.4.2 转换。

将字符串变成字符串数组(字符串的切割)

String[] split(String regex):涉及到正则表达式.

将字符串变成字符数组。

char[] toCharArray();

将字符串变成字节数组。

byte[] getBytes();

将字符串中的字母转成大小写。

String toUpperCase():大写

String toLowerCase():小写

将字符串中的内容进行替换

String replace(char oldch,char newch);

String replace(String s1,String s2);

将字符串两端的空格去除。

String trim();

将字符串进行连接。

String concat(string);

1.4. 3 判断

两个字符串内容是否相同啊？

boolean equals(Object obj);

boolean equalsIgnoreCase(string str);忽略大写比较字符串内容。

字符串中是否包含指定字符串？

boolean contains(string str);

字符串是否以指定字符串开头。是否以指定字符串结尾。

boolean startsWith(string);

boolean endsWith(string );

1.4.4 比较

按字典顺序比较两个字符串。

int compareTo(String antherString);

按字典顺序比较两个字符串，不考虑大小写。

int compareToIngoreCase(String str);

字符串练习1:

public class StringMethodDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		stringMethodDemo();
	}

	public static void stringMethodDemo() {
		// TODO Auto-generated method stub
		String s="abcdefag";
		System.out.println("length="+s.length());//8
		System.out.println("index a="+s.charAt(3));//d
		System.out.println("index a="+s.indexOf('a'));//0
		System.out.println("lastIndex"+s.lastIndexOf('a'));//6
		
	}

}

字符串练习2：

/*
 * 获取字符串出现的次数
 */
public class StringExercise {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String str="abcndnabckdjabcuejabcdd";
		String Key="abc";
		
		int count=getCount(str,Key);
		System.out.println("count="+count);
	}

	public static int getCount(String str,String key) {
		// TODO Auto-generated method stub
	
		int index = 0;
		int count = 0;
		while ((index = str.indexOf(key,index)) != -1){
			index = index + key.length();
		count++;
		}
		return count;
		
	}

}

字符串练习3：

//取最长的子字符串
public class StringExercise2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String s1="adfdhfghtdkdidd";
		String s2="djdkfghtedj";
		String s=getMaxSubstring(s1,s2);//取最大的子字符串
		System.out.println("s="+s);

	}

	private static String getMaxSubstring(String s1, String s2) {
		
		// TODO Auto-generated method stub
		String max = null, min = null;
		max = (s1.length() > s2.length()) ? s1 : s2;
		min = max.equals(s2) ? s1: s2;
		System.out.println("min="+min);
		System.out.println("max="+max);
		
		for (int i = 0; i < min.length(); i++) {
			for (int x = 0, y = min.length() - i; y != min.length() + 1; x++, y++) {
				String sub = min.substring(x, y);

				System.out.println(sub);
				if (max.contains(sub))
					return sub;
			}
				
		}	 
		return null;
	}

}

字符串练习4：

/*
 * 对一个字符串进行从小到大的排序"50 20 -36 64 21 10 57 -25"
 * 思路：1.先将字符串按空格切割转换成字符数组
 *     2.将字符数组转换成int数组
 *     3.然后将int数组排序
 *     4.将排序后数组转换成字符串
 */

public class StringExercise3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String s = "50 20 -36 64 21 10 57 -25";
		System.out.println("排序前:"+s);
		String[] arr = stringToArray(s);
		int[] arrInt = stringTointArray(arr);

	
		Arrays.sort(arrInt);
		intToString(arrInt);

	}

	private static void intToString(int[] arrInt) {
		// TODO Auto-generated method stub
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < arrInt.length; i++) {
			if (i != arrInt.length - 1)

				sb.append(arrInt[i] + " ");
			else
				sb.append(arrInt[i]);

		}

		System.out.println("排序后："+ sb.toString());

	}

	public static String[] stringToArray(String s) {
		// TODO Auto-generated method 
		String[] arr1 = s.split(" ");

		return arr1;

	}

	public static int[] stringTointArray(String[] arr) {
		// TODO Auto-generated method 
		int[] arrInt = new int[arr.length];

		for (int index = 0; index < arr.length; index++) {

			arrInt[index] = Integer.parseInt(arr[index]);
		}

		return arrInt;

	}

}

字符串练习5：

/*
 * 1，给定一个字符串数组。按照字典顺序进行从小到大的排序。
 * {"nba","abc","cba","zz","qq","haha"}
 * 
 * 思路：
 * 1,对数组排序。可以用选择，冒泡都行。
 * 2,for嵌套和比较以及换位。
 * 3,问题：以前排的是整数，比较用的比较运算符，可是现在是字符串对象。
 *   字符串对象怎么比较呢？爽了，对象中提供了用于字符串对象比较的功能。
 * 
 */
public class StringTest_1 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		String[] arr = { "nba", "abc", "cba", "zz", "qq", "haha" };

		printArray(arr);

		sortString(arr);

		printArray(arr);

	}

	public static void sortString(String[] arr) {

		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = i + 1; j < arr.length; j++) {

				if(arr[i].compareTo(arr[j])>0)//字符串比较用compareTo方法
					swap(arr,i,j);
			}
		}
	}

	private static void swap(String[] arr, int i, int j) {
		String temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}

	public static void printArray(String[] arr) {
		System.out.print("[");
		for (int i = 0; i < arr.length; i++) {
			if (i != arr.length - 1)
				System.out.print(arr[i] + ", ");
			else
				System.out.println(arr[i] + "]");
		}
	}

}

2.StringBuffer

1. 字符串的组成原理就是通过该类实现的。
2. StringBuffer可以对字符串内容进行增删。
3. StringBuffer是一个容器。
4. 很多方法与String相同。
5. StingBuffer是可变长度的。

2.1 StringBuffer 的常用操作

2.1.1.添加：

StringBuffer append(data);

StringBuffer insert(index,data);

2.1.2删除：

StringBuffer delete(start,end):包含头，不包含尾。

StringBuffer deleteCharAt(int index):删除指定位置的元素

2.1.3.查找：

char charAt(index);

int indexOf(string);

int lastIndexOf(string);

2.1.4.修改：

StringBuffer replace(start,end,string);

void setCharAt(index,char);

增删改查 C(create)U(update)R(retrieve)D(delete)

2.2 StringBulider

jdk1.5以后出现了功能和StringBuffer一模一样的对象。就是StringBuilder

不同的是：

StringBuffer是线程同步的。通常用于多线程。

StringBuilder是线程不同步的。通常用于单线程。它的出现提高效率。

public class StringBuilderTest {

		public static void main(String[] args) {

			int[] arr = {3,1,5,3,8};
			String s = arrayToString_2(arr);
			
			System.out.println(s);
		}
		
		/**
		 * 将一个int数组变成字符串。
		 */
		public static String arrayToString_2(int[] arr){
			
			StringBuilder sb = new StringBuilder();
			sb.append("[");
			for (int i = 0; i < arr.length; i++) {
				if(i!=arr.length-1)
					sb.append(arr[i]+", ");
				else
					sb.append(arr[i]+"]");
			}
			return sb.toString();
		}
		
		/**
		 * 将一个int数组变成字符串。
		 */
		public static String arrayToString(int[] arr){
			
			String str = "[";
			for (int i = 0; i < arr.length; i++) {
				if(i!=arr.length-1)
					str+=arr[i]+", ";
				else
					str+=arr[i]+"]";
			}
			
			return str;
		}

	}

3.基本数据类型对象包装类

3.1 为了方便操作基本数据类型值，将其封装成了对象，在对象中定义了属性和行为丰富了该数据的操作。
用于描述该对象的类就称为基本数据类型对象包装类。

  byte ---> Byte
  short ---> Short
  int ---> Integer
  long ---> Long
  float ---> Float
  double ---> Double
  char ---> Character
  boolean ---> Boolean

3.2. 该包装对象主要用基本类型和字符串之间的转换。

3.2.1基本类型--->字符串

   1,基本类型数值+" "

   2,用String类中的静态方法valueOf(基本类型数值);

   3,用Integer的静态方法valueOf(基本类型数值);

3.2.2字符串--->基本类型

1,使用包装类中的静态方法 xxx parseXxx("xxx类型的字符串");

   int parseInt("intstring");

   long parseLong("longstring");

   boolean parseBoolean("booleanstring");

   只有Character没有parse方法

2,如果字符串被Integer进行对象的封装。

可使用另一个非静态的方法，intValue();

将一个Integer对象转成基本数据类型值。

3.3 基本数据类型对象包装类新特性

JDK1.5以后，简化了定义方式。

Integer x = new Integer(4);可以直接写成

Integer x = 4;//自动装箱。

x = x + 5;//自动拆箱。通过intValue方法。

3.4整数具备不同的进制体现。

十进制-->其他进制。

toBinaryString

toOctalString

toHexString

其他进制-->十进制。

parseInt("string",radix)

public class WrapperDemo {

		public static void main(String[] args) {

			int num = 4;
			num = num + 5;
			
			Integer i =  4;//i = new Integer(4);自动装箱  简化书写。
			i = i + 6;// i = new Integer(i.intValue() + 6); //i.intValue() 自动拆箱

			Integer a = new Integer(127);
			Integer b = new Integer(127);
			System.out.println(a==b);//false
			System.out.println(a.equals(b));//true
			
			Integer aa = new Integer(128);
			Integer bb = new Integer(128);
			
			System.out.println(aa==bb);//false
			System.out.println(aa.equals(bb));//true
			
			Integer x = 127;//jdk1.5以后，自动装箱，如果装箱的是一个字节，那么该数据会被共享不会重新开辟空间。
			Integer y = 127;
			System.out.println(x==y);//true
			System.out.println(x.equals(y));//true
			
			Integer xx = 129;//jdk1.5以后，自动装箱，如果装箱的是一个字节，那么该数据会被共享不会重新开辟空间。
			Integer yy = 129;
			System.out.println(xx==yy);//false
			System.out.println(xx.equals(yy));//true
			
			
		}

	}