String类

1，对象是怎么创建的？

构造函数的几种情形

2，有哪些方法以及方法是怎么用的？

下面介绍的有。

String类的构造函数

String(char[] value, int offset, int count）

如果后面的两个数，如果第一个数从0开始，就是含头不含尾，如果不是。则从Offset开始，count为总共截取的位数·

package String;

import org.junit.Test;

public class Stringdemo {
	@Test
	public void  testConstructor(){
		//1.把字符串数据转成字符串对象
		String str1 = new String("java");
		//2,把字符数据转化成字符串对象
		char[] values = { 'j', 'a', 'v', 'a'};
		String str2 = new String(values);
		String str3 = new String(values, 0, 3);
			//把字符数组转成字符串对象
		//3.把字节数组转成字符串对象

		byte[] bytes ={98,97,79,99};
		String st4 = new String(bytes);
		System.out.println(st4);
	}
	
}

String类的常用方法

* 1.判断功能
* equals(Object o) 比较字符串的内容是否相同
* equalsIgnoreCase(String another) 比较字符串的内容是否相同，忽略大小写
* startsWith(String str) 是否以指定字符串开头
* endsWith(String str)是否以指定字符串结尾
* contains(charSequece c) 是否包含指定字符
2.获取功能
* length() 返回字符串长度
* charAt(int index) 根据位置获取字符
* indexOf(String str)获取字符串首次出现的位置
* indexOf(String str, int from)获取字符串在指定位置开始,首次出现的位置
* indexOf(int ch)获取字符首次出现的位置
* indexOf(int ch, int from)获取字符在指定位置开始,首次出现的位置
*
* lastIndexOf(String str)获取字符串最后一次出现的位置
* lastIndexOf(String str, int from)获取字符串在指定位置开始,最后一次出现的位置
* lastIndexOf(int ch)获取字符最后一次出现的位置
* lastIndexOf(int ch, int from)获取字符在指定位置开始,最后一次出现的位置
* 截串
* substring(int begin) 从begin开始，一直到末尾
* substring(int begin ,int end) 含头部含尾
3.转换功能
toCharArray() 字符串转成字符数组
str.getBytes();根据系统默认码表转成字节数组
str.getBytes(String charSetName); 根据指定码表转成字节数组
toUpperCase() 小写转大写
toLowerCase() 大写转小写
trim() 去除字符串两边的空格、
concat(String str) 拼接字符串
replace(String old, String new) 新替旧
replace(char old, char new) 新替旧
split(String regex) 以指定字符串切割，返回字符串数组 (正则表达式)

import org.junit.Test;

public class StringDemo2 {
	
	
	
	@Test
	public void test1(){
		String str1 = "abc";
		String str2 = "ABC";
//		System.out.println(str1.equalsIgnoreCase(str2));
		
		System.out.println(str1.contains("b"));
	
	}
	@Test
	public void test2(){
		String str = "abac";
//		System.out.println(str.length());
//		System.out.println(str.charAt(0));
//		System.out.println(str.indexOf("a"));
		//int indexOf = str.indexOf("a", 3);
//		int indexOf = str.indexOf('a', 1);
//		int lastIndexOf = str.lastIndexOf("c");
		String substring = str.substring(1);
		String substring2 = str.substring(1, 3);
		System.out.println(substring2);
	}
	
	@Test
	public void test3(){
//		String str = "   ABC  DEFG  ";
//		//char[] charArray = str.toCharArray();
//		//String upperCase = str.toLowerCase();
//		String trim = str.trim();
//		String concat = trim.concat("xxx");
		System.out.println(concat);
//		
//		String replace = str.replace("D", "ww");
//		
//		System.out.println(replace);
		
		String str = "a,b,c,d,e,f";
		String[] split = str.split(",");
		for(String ss : split){
			System.out.println(ss);
		}
	}
}

String练习

1、给定一个字符串数组。按照字典顺序进行从小到大的排序

package String;

public class StringTest1 {
	public static void main(String[] args) {
		String[] strs = {	"abc","ac","absfaf","a"};
		printArr(strs);
		//排序
		sort(strs);
		printArr(strs);
	}
	//	按照字典顺序从小到大排序
	//前面的选择排序
	private static void sort(String[] strs) {
		for(int i = 0;i<strs.length -1;i++){
			for(int j = i+1; j<strs.length; j++){
				if((strs[i].compareTo(strs[j])) > 0){//前面的与后面的靠前返回二者ASCII的值，相等 0；
					//换位置
					swap(strs, i, j);
				}
			}
		}
	}

	private static void swap(String[] strs, int i, int j) {
		String tem = strs[i];
		strs[i] = strs[j];
		strs[j] = tem;
	}
	private static void printArr(String[] strs) {
		System.out.print("[");
		for(int i = 0; i< strs.length;i++){
			if( i != strs.length-1){
				System.out.print(strs[i] + ",");
			}else{
				System.out.println(strs[i] + "]");
			}
		}
	}
}

2、一个子串在整串中出现的次数

不考虑时间复杂度，用数据结构中的知识做，至少有两种，一种kmp算法，一种bp算法如下，此外运用String类中的函数，本质上其实是一样的，只不过是把算法都封装了。

public class StringTest2 {
	public static void main(String[] args) {
		String str = "abacgfdacabacberacj";
		String subStr = "ac";
		int count =  getCount(str, subStr);
		System.out.println(count);
	}

	private static int getCount(String str, String subStr) {
	//记录次数
		int count = 0;
		//2,记录subStr首次出现的位置
		int start = 0;
		while((start = str.indexOf(subStr)) != -1 ){
			str = str.substring(start, subStr.length());
			count++;
		}
		return count;
	}
}

3，两个字符串中最大相同的子串。

public class StringTest3 {
	public static void main(String[] args) {
		String str1 = "abcdefghijk";
		String str2 = "wqcdefpm";
		String max = getMaxString(str2, str1);
		System.out.println(max);
		
	}

	private static String getMaxString(String str2, String str1) {
		String max = null;
		String min = null;
		max = (str1.length() > str2.length() )? str1: str2;
		min = (str1.length()<str2.length())? str1 : str2;
		for(int i = 0; i < min.length(); i++){
			for(int x = 0, y = min.length() - i; y != min.length()+1;x++,y++){
				String substring = min.substring(x,y);
				if(max.contains(substring)){
					return substring;
				}
			}
		}
		return null;
	}
}

4、模拟一个trim功能一致的方法，去除字符串两端的空白。

这几题都是算法题，等这阵子忙完了，再做点acm题。。。


public class StringText4 {
	public static void main(String[] args) {
		String str = "x yw           ";
		String ss = myTrim(str);
		System.out.println(ss);
	}
	private static String myTrim(String str){
		int start = 0;
		int end = str.length() - 1;
		while(start <= end && str.charAt(start) == ' '){
			start++;
		}
		while(start <= end && str.charAt(end) == ' '){
			end--;
		}
		return str.substring(start,end+1);	
	}
}

StringBuffer:字符串缓冲区

用于存储数据的容器

  * 特点：
       *        1.长度可变
       *        2.存储不同类型的数据
       *        3.最终都要转成字符串进行使用
       *        4.可以对字符串进行修改
       *
       * 这个容器的具有哪些功能呢？
       *
       * 1.添加
       *        append(obj)
       *        insert(idnex, obj)
       * 2.修改
       *        sb.replace(start, end, str); 替换多个
       *        sb.setCharAt(index, char); 替换单个
       * 3.删除
       *        sb.deleteCharAt(index);删除单个
       *        sb.delete(start, end);删除多个
       * 4.查找
       *        char charAt = sb.charAt(index); 查找单个
       *        int indexOf = sb.indexOf(str);
       *        int indexOf = sb.lastIndexOf(str);

public class StringBufferDemo {

	public static void main(String[] args) {
		
		StringBuffer sb = new StringBuffer();
		
		sb.append("a").append("xx").append(true);
		sb.insert(0, false);
		System.out.println(sb.toString());
		//sb.replace(0, 2, "w");
		//sb.setCharAt(0, 'p');
		//sb.deleteCharAt(0);
		//sb.delete(0, 2);
		//char charAt = sb.charAt(0);
		int indexOf = sb.lastIndexOf("x");
		System.out.println(indexOf);
		
		
		/*
		 * StringBuilder  jdk1.5版本之后出现的，和StrinbBuffer功能一样
		 * 
		 * 不同：
		 * StrinbBuffer 线程安全的 ，用于多线程
		 * StringBuilder 线程不安全的，用于单线程
		 * 
		 */
	}

}

String StringBuffer StrinBuilder

String:字符串常量，对象已创建不可更改
StringBuffer StringBuilder：字符串变量，对象创建完之后，可以更改

String str = “abc”;
System.out.println(str); //abc
str = str + “de”;
System.out.println(str); //abcde

1.运行速度

2.线程安全问题

少量的字符串操作 String

多线程大量的对字符串进行操作 StringBuffer
单线程大量的对字符串进行操作 StringBuilder

效率:
StringBuilder > StringBuffer > String

日期类

1毫秒(ms)=0.001秒(s) 说实话，才知道。。。

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

import org.junit.Test;

/*
 * 与时间相关的类
 * 	1.System
 * 	2.Date
 * 	3.SimpleDateFormat
 * 	4.Calendar
 */
public class DateDemo {
	
	@Test
	public void testSystem(){
		long start = System.currentTimeMillis();
		for(int i=0; i<10000; i++){
			
			for(int j=0; j<10000; j++){
				
			}
		}
		
		long end = System.currentTimeMillis();
		
		System.out.println(end - start);
	}
	
	@Test
	public void testDate(){
		Date d = new Date();//当前的时间对象,1549969447319
		System.out.println(d);
		//1.日期对象 -->毫秒值  getTime()
		long time = d.getTime();
		
		
		//2.毫秒值 --> 日期对象   构造函数
		Date dd = new Date(1549969447319L);
		System.out.println(dd);
	}
	
	@Test
	public void testSimpleDateFormat() throws ParseException{
		Date d = new Date();
		
		//需要格式化日期
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy--MM--dd HH-mm-ss");
		--
		//1.把日期对象转换成自定义格式的文本
		String format = sdf.format(d);
		
		
		String str = "2019*2*12---19:15:02";
		SimpleDateFormat sf = new SimpleDateFormat("yyyy*MM*dd---HH:mm:ss");
		
		//2.把指定格式的日期文本转换成日期对象
		Date parse = sf.parse(str);
		
		System.out.println(parse);
	}
	
	@Test
	public void testCalendar(){
		Calendar c = Calendar.getInstance();
		//int i = c.get(Calendar.DAY_OF_MONTH);
		
//		c.set(Calendar.DAY_OF_MONTH, 2);
		c.add(Calendar.DAY_OF_MONTH, -2);
		Date d = c.getTime();
		
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
		String format = sdf.format(d);
		System.out.println(format);
	}
	
}

MAth类

import org.junit.Test;

public class MathDemo {
	
	@Test
	public void testMath(){
		/*
		 * Math:用于执行基本数学运算的方法
		 * 
		 * Math.E     e
		 * 
		 * Math.PI     π
		 * 
		 * Math.floor(1.6);//向下取整
		 * Math.ceil(1.3);//向上取整
		 * Math.round(1.5);//四舍五入
		 * Math.random();//随即生成数
		 */
		
		double floor = Math.floor(-0.9);//向下取整
		double ceil = Math.ceil(1.3);//向上取整
		long round = Math.round(1.5);//四舍五入
		
		for(int i=0; i<20; i++){
			double random = Math.random();//随即生成数，0.0-1.0之间，包含0.0-，不包含1.0
			System.out.println(random);
		}
		
		
		//随即生成一个1-10之间的数   1，2，3，4，5，6
		myRandom();
	}

	private void myRandom() {
		for(int i=0; i<10; i++){
			System.out.println((int)Math.floor(Math.random()*10 + 1));
		}
	}
}

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/114801.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权正版激活】： 官方授权正版激活支持Jetbrains家族下所有IDE 使用个人JB账号...