day11java基础

最新推荐文章于 2024-03-15 14:11:21 发布

canoe_df

最新推荐文章于 2024-03-15 14:11:21 发布

阅读量183

点赞数

本文链接：https://blog.csdn.net/canoe_df/article/details/78417288

版权

一.String类中的其它功能

1.替换功能:
public String replace(char oldChar,char newChar):将字符串中某一个字符用新的字符替换
public String replace(String oldStr,String newStr):将字符串中某一个子字符串用新的字符串去替代

2.去除字符串两端空格:
public String trim()

3.两个字符串进行比较:
public int compareTo(String anotherString) 是Comparable接口中的方法(该接口可以实现一个自然排序)

例子：

public class StringDemo {
	
	public static void main(String[] args) {
		
		//定义字符串
		String s1 = "helloworld" ;
		
		//替换功能
//		public String replace(char oldChar,char newChar):将字符串中某一个字符用新的字符替换
//		String s2 = s1.replace('l', 'k') ;
//		System.out.println("s:"+s2);
		//public String replace(String oldStr,String newStr):将字符串中某一个子字符串用新 的字符串去替代
		String s3 = s1.replaceAll("owo", "ak47") ;
		System.out.println("s3:"+s3);
		
		System.out.println("------------------");
		
		String s4 = " hello world " ;
		System.out.println("s4:"+"----"+s4+"----");
		//public String trim()
		String s5 = s4.trim() ;
		System.out.println("s5:"+"----"+s5+"----");
		
		//public int compareTo(String anotherString)
		String s6 = "hello" ;
		String s7 = "hello" ;
		String s8 = "abc" ;
		System.out.println("compareTo():"+s6.compareTo(s7));
		System.out.println("compareTo():"+s6.compareTo(s8));
	}
}

二.StringBuffer

1.StringBuffer的构造方法:
   public StringBuffer ()构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符
   public StringBuffer(int capacity)构造一个不带字符，但具有指定初始容量的字符串缓冲区
   public StringBuffer(String str)构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。该字符串的初始容量为 16 加上字符串参数的长度。

   2.常用的功能:
   public int length():获取字符串长度数
public int capacity():获取当前字符串缓冲区的容量

例子：

public class StringBufferDemo {
	
	public static void main(String[] args) {
//		StringBuffer sb = "hello" ;
//		String s = "hello" ;
//		StringBuffer sb = s ;
		
//		public StringBuffer	()构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符
		//创建一个字符串缓冲区对象
		StringBuffer sb = new StringBuffer() ;
		System.out.println("sb.length:"+sb.length());
		System.out.println("sb.capacity:"+sb.capacity());//16
		
		System.out.println("----------------------------");
		
		//	public StringBuffer(int capacity)构造一个不带字符，但具有指定初始容量的字符串缓冲区
		StringBuffer sb2 = new StringBuffer(50) ;
		System.out.println("sb2.length:"+sb2.length());
		System.out.println("sb2.capacity:"+sb2.capacity());//50
		
		System.out.println("----------------------------");
		
		StringBuffer sb3 = new StringBuffer("hello") ;
		System.out.println("sb3.length:"+sb3.length());
		System.out.println("sb3.capacity:"+sb3.capacity());//默认:初始容量16 + 当前字符串长度
		
	}
}

面试题:
StringBuffer和String 的区别?
StringBuffer会构造一个字符串缓冲区,从内存角度考虑,一般情况使用StringBuffer比较多(在单线程程序中使用StringBulider替代
StringBuffer:线程不安全,单线程单纯为了提供执行效率!)
String:普通的一个字符串,从内存角度考虑,耗费空间!

3.StringBuffer中的和添加有关的方法
public StringBuffer append(int/String/char/boolean/double/float....):当前这个方法追加,给缓冲中追加数据,返回字符串缓冲区本身(经常使用的)
public StringBuffer insert(int offset,String str):在某一个位置处去插入str这个字符串,返回字符串缓冲区本身

例子：

public class StringBufferDemo2 {
	
	public static void main(String[] args) {
		
		//创建一个字符串缓冲区对象
		StringBuffer sb = new StringBuffer() ;
		
		//追加数据
	/*	sb.append("hello") ;
		sb.append(true) ;
		sb.append(13.45) ;
		sb.append('A') ;
		sb.append(12.56F);*/
		
		//链式编程
		sb.append("hello").append(true).append(13.45).append('A').append(12.56F);
		
		//public StringBuffer insert(int offset,String str):在某一个位置处去插入str这个字符串,返回字符串缓冲区本身
		
		sb.insert(5, "world") ;
		//输出
		System.out.println("sb:"+sb);
	}
}

4.StringBuffer的删除功能:
public StringBuffer deleteCharAt(int index):删除指定位置处的字符,返回的是字符串缓冲区本身!
public StringBuffer delete(int start,int end):删除从指定位置开始到指定位置结束的字符,返回的是字符串缓冲区本身!

例子：

public class StringBufferDemo3 {
	
	public static void main(String[] args) {
		//创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer() ;
		
		//给缓冲区追加数据
		sb.append("hello") ;
		sb.append("world") ;
		sb.append("java") ;
		
		public StringBuffer deleteCharAt(int index)
		//需求:要删除当前缓冲区中'e'这个字符
//		sb.deleteCharAt(1) ;
		//需求:要删除当前缓冲区中第一个'l'这个字符
//		sb.deleteCharAt(1) ;
		
//		public StringBuffer delete(int start,int end)
//		sb.delete(5, 9) ;
		//从0索引开始,当前缓冲的字符串全部删除掉
		sb.delete(0, sb.length()) ;
		
		//输出
		System.out.println("sb:"+sb);
	}
}

5.StringBuffer的反转功能:
public StringBuffer reverse():将此字符串中的字符序列直接反转
例子：

public class StringBufferDemo4 {
	
	public static void main(String[] args) {
		
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//录入并接收数据
		System.out.println("请您输入一个字符串:");
		String line = sc.nextLine() ;
		
		//可以创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer(line) ;
		//public String toString():现在的数据类型StirngBuffer类型,需要将StringBuffer类型转换String
		//反转功能
		 String result = sb.reverse().toString() ;
		 System.out.println("result:"+result);
		
		
	}
}

6.StringBuffer的替换功能:
public StringBuffer replace(int start, int end,String str)
从指定位置开始到指定位置结束的字符用str子字符串去替代

例子：

public class StringBufferDemo5 {
	
	public static void main(String[] args) {
		
		//创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer() ;
		
		//给缓冲添加数据
		sb.append("hello") ;
		sb.append("world") ;
		sb.append("java") ;
		
		//public StringBuffer replace(int start, int end,String str)
		sb.replace(5, 10, "节日快乐") ;
		
		System.out.println("sb:"+sb);
	}
}

7.StringBuffer的截取功能:
public String substring(int start):从指定位置默认截取到末尾,返回值是一个新的字符串
public String substring(int start,int end):从指定位置开始截取到指定位置结束,包前不包后,返回一个新的字符串

例子：

public class StringBufferDemo6 {
	
	public static void main(String[] args) {
		//创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer() ;
		
		//添加
		sb.append("hello") ;
		sb.append("world") ;
		sb.append("java") ;
		
		
		
		
		//public String substring(int start)
//		String s1 = sb.substring(5) ;
//		System.out.println("s1:"+s1);
		
		//public String substring(int start,int end)
		String s2 = sb.substring(5,10) ;
		System.out.println("s2:"+s2);
		System.out.println("sb:"+sb);
	}
}

面试题:
   String,StringBuffer,StringBuilder的区别?

   String:一个不可变的字符序列,StringBuffer:和StringBuilder是可变的字符序列,在单个线程时候的时候(优先采用StringBuilder)
从线程角度考虑:
StringBuilder线程不安全,不同步,执行效率高!它比StringBuffer要快!

面试题:
   StringBuffer和数组的区别?

   两个共同特点:都属于容器类型的变量
   数组:只能存储同一种数据类型的元素,数组的长度是固定的
   int[] arr = {10,20,40,50,"hello"} 错误的
   StringBuffer:字符串缓冲区,可以存储任意类型的元素,可以不断的去给缓冲区中追加(append),字符串缓冲区中:在内存始终返回的字符串

类与类之间的转换
   A类型--->B类型
   这里面可能最终使用B类型里面的功能
   B类型--->A类型
   有时候需要的不是B类型,所以又要将B类型-->A类型

StringBuffer--->String之间的相互转换

例子：

public class StringBufferTest {
	
	public static void main(String[] args) {
		//String--->StringBuffer
		//定义一个字符串
		String s = "hello" ;
		
		/*StringBuffer sb = "hello" ;
		StringBuffer sb = s ;*/
		//方式1)使用StringBuffer的构造方式:StringBuffer(String str)
		//创建一个字符串缓冲区并指向这个字符串
		StringBuffer sb = new StringBuffer(s) ;
		System.out.println("sb:"+sb);
		
		//方式2)创建字符串缓冲区对象,使用无参构造StringBuffer(),利用append()
		StringBuffer sb2 = new StringBuffer() ;
		sb2.append(s) ;
		System.out.println("sb2:"+sb2);
		
		System.out.println("--------------------");
		
		//StringBuffer--->String
		//有一个字符串缓冲区对象
		StringBuffer buffer = new StringBuffer("world") ;
		//1)方式1String的另一种构造方法:String(StringBuffer buffer)
		String s2 = new String(buffer) ;
		System.out.println("s2:"+s2);
		//2)方式2:/public String toString():现在的数据类型StirngBuffer类型,需要将StringBuffer类型转换String
		String s3 = buffer.toString() ;
		System.out.println("s3:"+s3);
	}
}

二.Integer

1.说明：java的jkd5.0以后:还有一些新特性:自动拆装箱,可变参数,增强for循环,静态导入,枚举...

对于每个基本数据类型都会被自动封装成一个引用类型
   基本类型引用类型
   int Integer
   char Character
   byte Byte
   boolean Boolean
   double Double
   float Float
   long Long
short Short

将基本类型--->引用类型的作用:就是为了和String类型作为转换

举例：

public class IntegerDemo {
	
	public static void main(String[] args) {
		//public static String toBinaryString(int i)
		System.out.println(Integer.toBinaryString(100)) ;
		
		//public static String toOctalString(int i)
		System.out.println(Integer.toOctalString(100));
		
		//public static String toHexString(int i)
		System.out.println(Integer.toHexString(100));
		
		//public static final int MAX_VALUE
		//public static final int MIN_VALUE
		System.out.println(Integer.MAX_VALUE);//2147483647
		System.out.println(Integer.MIN_VALUE);//-2147483647
	}
}

2.Integer类的构造方式:
   public Integer(int value):将一个int类型的数据封装成一个引用类型
   public Integer(String s):将一个字符串类型封装成一个Integer类型
注意事项:
   该字符串必须是数字字符串!,否则:java.lang.NumberFormatException

例子：

public class IntegerDemo2 {
	
	public static void main(String[] args) {
//		public Integer(int value)
		//创建一个Integer对象
		Integer i = new Integer(100);
//		Integer i = 100 ;//jdk5以后的自动装箱!
		System.out.println("i:"+i);
		
		//public Integer(String s)
//		String s = "abc" ;
		String s = "20" ;
		Integer ii = new Integer(s) ;
		System.out.println("s:"+s);
	}
}

3.int类型和String类型的相互转换

例子：

public class IntegerTest {
	
	public static void main(String[] args) {
		
		//定义一个int类型的数据
		int number = 100 ;
		
		//方式1)字符串拼接符
		String s1 = "" + number ;
		System.out.println("s1:"+s1);
		
		//方式2:int--->Integer类型
		Integer i = new Integer(number) ;
		//Integer--->String
		//public String toString()
		String s2 = i.toString() ;
		System.out.println("s2:"+s2);
		
		//方式3)public static String toString(int i)
		String s3 = Integer.toString(number) ;
		System.out.println("s3:"+s3);
		//方式4)
		//public static Integer valueOf(int i)
		Integer integer= Integer.valueOf(number) ;
		String s4 = integer.toString() ;
		System.out.println("s4:"+s4);
		
		System.out.println("---------------------------");
		
		//定义一个字符串:
		String s = "10" ;
		//方式1:String--->Integer---->int
		Integer ii = new Integer(s) ;
		//public int intValue()以 int 类型返回该 Integer 的值
		int num = ii.intValue() ;
		System.out.println("num:"+num);
		//public static int parseInt(String s)
		int num2 = Integer.parseInt(s) ;
		System.out.println("num2:"+num2);
		
		
		//Integer的内存缓存区:IntegerCashe
		//low = -128
		//high=127
		Integer i1 = 127 ;		//----->底层在封装的时候:Integer integer = Inteter.valueOf(int i) ;
		Integer i2 = 127 ;
		
		
		
		System.out.println(i1==i2);//true
		Integer i3 = 128 ;
		Integer i4 = 128 ;
		System.out.println(i3==i4);//false

	}
}

4. Jdk5.0以后的新特性:自动拆装箱

例子：

public class IntegerTest2 {
	
	public static void main(String[] args) {
		//创建一个Integer对象
		Integer i = new Integer(100) ;
		i += 200 ;
		System.out.println("i:"+i);
		
		/**
		 * 通过反编译工具查看源码:
		 * 	Integer i = new Integer(100); //将int类型值通过构造的形式自动装箱为Integer类型
			i = Integer.valueOf(i.intValue() + 200);//i.intValue()--->int类型的数据:把Integer--->int:自动拆箱
			自动装箱了
			System.out.println((new StringBuilder("i:")).append(i).toString());
		 */
	}
}

三.character类

1. Character 类在对象中包装一个基本类型 char 的值。Character 类型的对象包含类型为 char 的单个字段
2. 构造方法:
public Character(char value)构造一个新分配的 Character 对象，用以表示指定的 char 值。
例子：

public class CharacterDemo {
	
	public static void main(String[] args) {
		//创建一个Character类的对象
//		Character character = new Character((char)97) ;
		Character character = new Character('a') ;
		System.out.println("character:"+character);
	}
}

3.Character类的判断功能:
   public static boolean isLowerCase(char ch)确定指定字符是否为小写字母。
   public static boolenn isUpperCase(char ch)确定指定字符是否为大写字母
   public static boolean isDigit(char ch)确定指定字符是否为数字。

4. Character常用的转换功能:
   public static char toUpperCase(char ch):将指定字符转换成大写
   public static char toLowerCase(char ch):将指定字符转换成小写

例子：

public class CharacterDemo2 {
	public static void main(String[] args) {
		
		//public static boolean isLowerCase(char ch)确定指定字符是否为小写字母
		System.out.println("isLowerCase:"+Character.isLowerCase('a'));
		System.out.println("isLowerCase:"+Character.isLowerCase('A'));
		System.out.println("isLowerCase:"+Character.isLowerCase('0'));
		System.out.println("---------------------------------------");
		//public static boolenn isUpperCase(char ch)确定指定字符是否为大写字母
		System.out.println("isUpperCase:"+Character.isUpperCase('a'));
		System.out.println("isUpperCase:"+Character.isUpperCase('A'));
		System.out.println("isUpperCase:"+Character.isUpperCase('0'));
		System.out.println("---------------------------------------");
		//public static boolean isDigit(char ch)确定指定字符是否为数字。
		System.out.println("isDigit:"+Character.isDigit('a'));
		System.out.println("isDigit:"+Character.isDigit('A'));
		System.out.println("isDigit:"+Character.isDigit('0'));
		
		
	}
}

冒泡排序的思想:
两两比较,大的往后放,第一次比完,最大值出现在最大索引处,依次进行这样的比较....

算法如下：

public static void bubbleSort(int[] arr){
		for(int x = 0 ; x < arr.length-1; x ++){
			for(int y = 0 ; y < arr.length-1-x ; y++){
				//判断
				if(arr[y]>arr[y+1]){
					int temp = arr[y] ;
					arr[y] = arr[y+1] ;
					arr[y+1] = temp ;
				}
			}
		}
	}

canoe_df

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
day11java基础

一.String类中的其它功能替换功能: * public String replace(char oldChar,char newChar):将字符串中某一个字符用新的字符替换 * public String replace(String oldStr,String newStr):将字符串中某一个子字符串用新的字符串去替代 * 去除字符串两端空格: * public St
复制链接

扫一扫