java基础2

最新推荐文章于 2024-10-23 20:19:17 发布

原创最新推荐文章于 2024-10-23 20:19:17 发布 · 486 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#类 #StringBuffer和StringB #Java

java基础专栏收录该内容

4 篇文章

订阅专栏

本文详细介绍了Java中的String类特性，包括其不可变性、常量池存储机制及常用方法如charAt、indexOf等。同时对比了String与StringBuffer、StringBuilder的区别，并探讨了字符串缓冲区的使用场景。

<h1>String类</h1>
	<ul>
	<li>字符串是一个特殊的对象</li>
	<li>字符串一旦初始化就不可以被改变</li>
	<li>不能被继承</li>
	<li>String str1 ="abc“ 常量值</li>
	<li>string str2 = new String （"abc"）；对象</li>
	<li>有区别？</li>
	<li></li>
	</ul>
	<h1>String类的特点</h1>
	<ul>
	<li>java语言中用于描述最常见的字符串数据的对象。</li>
	<li>字符创都是一个对象。</li>
	<li>字符串数据一旦初始化就不可以改变。双引号表示的都是常量。</li>
	<li>
	<p>字符串对象都存储在常量值。字符串存储常量池</p>
	<ul>
	<li>String s1 ="abcd"</li>
	<li>String s2 ="abcd"</li>
	<li>String s3 ="ab"+"cd"</li>
	<li>s1==s2//false</li>
	<li>s1.equals(s2) true</li>
	<li>s3==s1 true</li>
	<li>String类是一个最终类</li>
	<li>基本数据用"=="比较相同。对象比较相同都用equals方法类覆盖了Object中的equals方法，比较的是字符串内容对象是否相同。</li>
	</ul>
	<h1>String类部分方法</h1>
	<ul>
	<li>char charAt(int index)</li>
	<li>int length()</li>
	<li>char[] toCharArray()</li>
	<li>int indexOf(String str)</li>
	<li>boolean endsWith(String str)</li>
	<li>String[] split(String reg)</li>
	<li>String substring(int index)</li>
	<li>String(char[] arr)</li>
	</ul>
	<p>package liwei.www.p1.string;</p>
	<p>public class StringDemo4 {</p>
	<pre><code>/**
	* @param args
	*/
	public static void main(String[] args) {
	// TODO Auto-generated method stub
	/*1 获取一个子串在字符串中出现的次数
	* 思路
	* 需要对nba的整串中进行查找
	* 如果找到了记下查找
	* 记下这个位置加nba长度的位置开始继续查找剩下的
	* 通过技术器来记录查找的次数
	* 步骤
	* 现有计数器变量记录每次出现的位置
	* 通过string类中的indexOf(方法)
	* 定义通过string类中的indexof方法来完成对字符串的索引。
	* 指定的肯能很多，需要字串有不断的查（循环、条件）找。
	*
	*/
	String str = "nbawernbayunbaidfnbaghjnba";
	String key ="nba";
	int count = getSubCount(str,key);
	System.out.println("count="+count);
	/* 2对字符串进行反转
	* "abcd"=>"dcba"*/
	/*
	* 2对字符串进行反转
	* 思路一看到反转，就想到数组的反转
	* 2可以将字符串看成数组
	* 3数组进行反转，无非是头尾脚元素互换位置
	* 4将数组变成字符串
	*/
	String s1 ="abcde";
	String s2 = reverseString(s1);
	System.out.println("s2="+s2);
	/*
	* 3对字符串中的字符进行排序
	* "cbda"=>"abcd";*/

	/*
	* 思路：
	* 1一看排序，就想到数组
	* 将字符串转成数组，
	* 对数组排序
	* 将排序的数组编成字符串
	*/
	String s3 = "cdebafq";
	s3 =sortString(s3);
	System.out.println("sort:"+s3);

	/* 4获取连个字符串中的最大相同的字符串
	* rtyuicctvopriyu ","cvbcctvnm"最大相同是cctv
	* */
	/*
	* 解决问题的思路
	* 较短的字符串，找到一个短的为参照，
	*
	* 然后看看得到字符创判断在不在长字符串
	* 2如果不包含，将短的长度一次递减的方式获取短串
	*/
	/*
	* 获取一个字符串冲出现的次数
	*@param str 指定的字符串
	*@param key要找的字符串
	*@return 返回key出现在Str的次数
	*/
	String s4 = "rtyuicctvopriyu";
	String s5 ="cvbcctvnm";
	String maxsub = getMaxString(s4,s5);
	System.out.println("maxsub:"+maxsub);
	}
	public static String getMaxString(String s4, String s5) {
	// TODO Auto-generated method stub
	for(int x =0;x<s5.length();x++){
	for(int y =0,z=s5.length()-x;z!=s5.length()+1;y++,z++){
	//获取s5的子串
	String temp = s5.substring(y, z);
	if(s4.contains(temp)){
	return temp;
	}
	}
	}
	return null;
	}
	//让字符串装换成字符数组
	private static String sortString(String s3) {
	// TODO Auto-generated method stub
	char[] ch = s3.toCharArray();
	sortChar(ch);
	return new String(ch);
	}
	//对字符数组进行排序
	private static void sortChar(char[] arr) {
	// TODO Auto-generated method stub
	//char temp =' ';
	for(int i =0;i<arr.length;i++){
	for(int j=i+1;j<arr.length;j++){
	if(arr[i]>arr[j]){

	char temp = arr[i];
	arr[i] = arr[j];
	arr[j] = temp;
	}
	}
	}

	}
	public static int getSubCount(String str,String key){
	//定义一个计数器，一个变量，一个记录位置
	int count = 0;
	int index = 0;
	//调用indexof得到
	while((index = str.indexOf(key, index))!= -1){
	index = index +key.length();
	count++;
	}
	return count;
	}
	/*
	* @param要反转的字符串
	* @返回结果新的字符串
	*/
	</code></pre>

	<p>public static String reverseString(String str){
	//将字符串转化成字符数组
	// String s = null;
	char [] chs = str.toCharArray();
	//reverseArray(chs);
	reverseArray(chs);
	return new String(chs);</p>
	<p>}
	/*</p>
	<ul>
	<li>
	将一个字符数组反转
	<em>/
	public static void reverseArray(char[] chs) {
	// TODO Auto-generated method stub
	for(int start =0,end=chs.length-1;start<end;start++,end--){
	swap(chs,start,end);
	}
	}
	/</em>对数组元素进行换位
	<ul>
	<li>*/
	private static void swap(char[] chs, int start, int end) {
	// TODO Auto-generated method stub
	char temp = chs[start];
	chs[start] = chs[end];
	chs[end] = temp;
	}
	}</li>
	</ul>
	</li>
	</ul>
	</li>
	</ul>
	<h1>StringBuffer</h1>
	<p>字符串缓冲区。StringBuffer：
	* 特点：
	* 1缓冲区就是用来缓存数据，意味这是一个容器
	* 2该容器的长度是可变的。
	* 3容器变成对象，它提供对内容操作(最多无外乎四种:增删改查)
	* 该缓冲区可以添加多种类型的元素，基本类型和应用类型
	* append()是在尾部追加
	* 如何任意添加Insert(int,object);
	* 无论怎么样改变容器中容器，要用到数据转换成字符串(toString())
	* delete(int start,int end)//删除 delete一段
	* 清空缓冲区 sb.delete(0,sb.length());
	* 修改一段
	* sb.replace(1,3,"ak47");
	* setChatAt()返回void
	*
	package liwei.www.p1.stringbuffer;</p>
	<pre><code>public class StringBufferDemo {

	/**
	* @param args
	*/
	public static void main(String[] args) {
	// TODO Auto-generated method stub
	/*
	* 字符串缓冲区。StringBuffer：
	* 特点：
	* 1缓冲区就是用来缓存数据，意味这是一个容器
	* 2该容器的长度是可变的。
	* 3容器变成对象，它提供对内容操作(最多无外乎四种:增删改查)
	* 4该缓冲区可以添加多种类型的元素，基本类型和应用类型
	*
	*/
	//创建字符串缓冲区
	//StringBuffer sb =new StringBuffer("abcd");
	//使用添加方法，往缓冲区中加入元素
	/*StringBuffer s1 = sb.append(45);
	System.out.println(sb==s1);//true append返回的原来的缓冲区
	sb.append(45).append(true).append("abc");*/ //连续添加，调用的动作，方法调用链
	/*
	* 字符串的底层运算
	* String str ="abc"+4+'c'
	* String str ="abc"+4+'c';
	* str = new StringBuffer().append("abc").append(4).append('c').toString();
	*/
	//sb.insert(1, "nba");
	//System.out.println(sb.toString());
	int[] arr ={1,2,3,78,34,48};
	System.out.println("arrtoStrimg:"+toString_1(arr));
	System.out.println("arrtoStrimg:"+toString_2(arr));
	}
	/*
	* 将一个int类型的数组变成字符串。[1,2,3]
	* 使用字符来完成
	*/
	public static String toString_1(int[] arr){
	String str ="[";
	for(int x=0;x<arr.length;x++){
	if(x!=arr.length-1){
	str+=arr[x]+",";
	}else{
	str+=arr[x]+"]";
	}
	}
	return str;
	}
	/*
	* 使用StringBuffer
	*/
	public static String toString_2(int[] arr){
	StringBuffer sb = new StringBuffer();
	sb.append("[");
	for(int x=0;x<arr.length;x++){
	if(x!=arr.length-1){
	sb.append(arr[x]+",");
	}else{
	sb.append(arr[x]+"]");
	}
	}
	return sb.toString();
	}
	}
	</code></pre>

	<p>StringBuffer对象长度可变的原理
	其实它里面是数组，可是这个为什么数组封装到StringBuffer
	初始化的长度，如果不够装，就把创建一个新的数组，长度增加一倍或者加原来的一般，把原来的数组复制到新的数组，其他在后面追加</p>
	<h1>StringBuilder</h1>
	<ul>
	<li>StringBuilder含义：</li>
	<li>jdk1.5版本出现了一个新的字符串缓冲区</li>
	<li>功能和StringBuffer一模一样</li>
	<li>StringBuffer有什么区别呢？</li>
	<li>StringBuffer是线程安全。</li>
	<li>StringBuilder是线程不安全的。</li>
	<li>如果一个容器创建，都是被一个线程，不安全或多线程的访问，单线程的时候用StringBuilder，提高了效率，因为不用判断锁，</li>
	</ul>
	<p>对于容器而已，被多线程操作，容易出现安全问题，因为一个线程负责添加，一个线程负责删除，因为线程的随机性，就会出现安全问题，要加锁，一个线程在执行容器中的内容时，其他线程不可以执行。
	所以凡是可以操作容器数据的方法，都需要明确这个锁
	每调用一次操作容器的方法，添加。删除，都需要判断这个锁
	对于多线程而言，安全了，但是效率底。
	对于单线程而言，不涉及安全，但是效率低，所以线程提供了StringBuilder.</p>
	<p>升级三件事，简化书写，提高效率，提高安全性</p>
	<h1>StringBuffer和数组容器的区别？</h1>
	<ul>
	<li>数组容器的固定长度</li>
	<li>StringBuffer是可变长度的</li>
	<li>2</li>
	<li>数组容器一点初始化就明确了元素的类型</li>
	<li>StringBuffer可以存储任意类型。包括基本和引用</li>
	<li>3</li>
	<li>数组存储元素可以对元素进行操作（通过角标）</li>
	<li>StringBuffer存储完元素后，都会变成字符串，只能用字符串的方法来操作</li>
	<li>什么时候用StringBuffer或者StringBuilder?</li>
	<li>数据个数是可以固定的，可是是不固定的，数据类型也可以是固定的，或者不固定的。</li>
	<li>只要最终做这些数据需要变成字符串来操作时，就可以使用字符串缓存区</li>
	<li></li>
	</ul>