学习Java时的代码笔记,排版可能有些问题,代码拿来直接就可以用,毕竟全手打,难免会有错,欢迎指正
/*
String类
字符串是一个特殊的对象
字符串一旦初始化就不可以被改变
String str = "abc";
String str1 = new String("abc");
有什么区别?
*/
class StringMainDemo1
{
public static void main(String[] args)
{
String s = new String(); //这种方式不多见
String s1 = ""; //这里和上面是一回事
String s2 = "abc";//s2是一个类类型变量,"abc"是一个对象
String s3 = new String("abc"); //和上面一回事
/*
S1和S2有什么区别
S1在内存中有一个对象
S2在内存中有两个对象
*/
System.out.println(s2==s3);
System.out.println(s2.equals(s3));
}
}
//==================================================================
class StringMainDemo2
{
public static void main(String[] args)
{
String s1 = "abc";
String s2 = new String("abc");
String s3 = "abc"; //发现abc已经存在了,它就不会在开辟空间了,而是直接引用,它们指向同一个对象
System.out.println(s1==s2);
System.out.println(s1==s3);
}
}
/*
String常见功能-获取和判断
String类适用于描述字符串事物
那么它就提供了多个方法对字符串进行操作
常见的操作有哪些?
1.获取
1.1 字符串中包含的字符数,也就是字符串的长度
int length() //返回此字符串的长度
1.2 根据位置获取位置上的某个字符
char charAt(int index)
1.3 根据字符获取该字符在字符串中的位置
它接受的是Acsii码,所以是int类型,它有重载形式
int indexOf(int ch) //返回ch在字符串中第一次出现的位置
int indexOf(int ch,int fromIndex)//从fromIndex指定位置开始,获取ch在字符串中出现的位置
int indexOf(String str) //返回str在字符串中第一次出现的位置
int indexOf(String str,int fromIndex)//从fromIndex指定位置开始,获取str在字符串中出现的位置
2.判断
2.1 字符串中是否包含某一个子串
boolean contains(str);
特殊之处:indexOf(str) //可以索引str第一次出现的位置,如果返回-1,表示该str不在字符串中存在
//所以,也可以用于对指定str判断是否包含
example:
if(str.indexOf("aa")!=-1) //那么包含
而且该方法既可以判断又可以获取出现的位置
那么判断时到底用哪个方法呢?
答:如果你只为判断,就用contains,如果你又想判断,又想获取出现的位置
那么就用indexOf
2.2 字符串中是否有内容
boolean isEmpty(); //原理就是判断,length是否为0
2.3 字符串是否是以指定内容开头
boolean startsWith(str);
2.4 字符串是否是以指定内容结尾
boolean endsWith(str);
2.5 判断字符串的内容是否相同
boolean equals(str); //重写了Object类中的equals方法
2.6 判断内容是否相同,并忽略大小写
boolean equalsIgnoreCase();
*/
class StringMainDemo3
{
public static void main(String[] args)
{
method_get();
method_is();
}
//获取
public static void method_get()
{
String str = "abcdeakpf";
//长度
sop(str.length());
//根据索引获取字符
sop(str.charAt(4));
//根据字符获取索引
sop(str.indexOf('a',3)); //如果没有找到,返回-1
//反向索引一个字符出现的位置
sop(str.lastIndexOf("a")); //角标不会发生改变
}
//判断
public static void method_is()
{
String str = "ArrayDemo.java";
//判断文件名称是否是Array单词开头
sop(str.startsWith("Array"));
//判断是否是.java的文件
sop(str.endsWith(".java"));
//判断文件名中是否包含Demo
sop(str.contains("Demo"));
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
/*
String-常见功能-转换
1.将字符数组转换成字符串
构造函数:String(char[])
String(char[],offset,count) //将字符数组中的一部分转换成字符串
静态方法:static String copyValueOf(char[]);
static String copyValueOf(char[] data,int offset,int count)
static String valueOf(char[]); //将基本数据类型转换成字符串
2.将字符串转换成字符数组
方法:char[] toCharArray()
3.将字节数组转换成字符串
构造函数:String(byte[])
String(byte[],offset,count) //将字节数组中的一部分转换成字符串
4.将字符串转换成字节数组
方法:byte[] getBytes()
*/
class StringMainDemo4
{
public static void method_trans()
{
char[] arr = {'a','b','c','d','e','f'};
String s = new String(arr);
System.out.println("s="+s);
//String s = new String(arr,1,3); //1表示从1下标开始,3表示取几个
//System.out.println("s="+s);
}
}
/*
String-常见功能-切割和替换
切割:
String[] split(regex); //regex表示分隔符
替换:
String replace(char oldChar,char newChar);
//如果要替换的字符不存在,返回的还是原串
子串:
String substring(int beginIndex) //获取一个字符串中的子串
String substring(int beginIndex, int endIndex)
*/
class StringMainDemo5
{
public static void main(String[] args)
{
method_replace();
method_split();
method_substring();
}
//切割
public static void method_split()
{
String s = "zhangsan,lisi,wangwu";
String[] arr = s.split(","); //利用,做分隔符来切割
for(int x=0; x<arr.length; x++)
{
sop(arr[x]);
}
}
//替换
public static void method_replace()
{
String s = "hello java";
String s1 = s.replace('a','n'); //把a替换成n
String s2 = s.replace("java","world"); //替换字符串
sop("s="+s);
sop("s1="+s1);
sop("s2="+s2);
}
//子串
public static void method_substring()
{
String s = "abcdef";
sop(s.substring(2));//从下标为2的开始到结尾处
sop(s.substring(2,4));//从下标为2的开始到以下标为0的开始到下标为4的位置
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
/*
String-常见功能-转换、比较和去除空格
转换:将字符串转换成大写或者小写
String toUpperCase();
String toLowerCase();
去除:将字符串两端的多个空格去除
String trim();
比较:对两个字符串进行自如顺序的比较
int compareTo(str);
*/
class StringMainDemo6
{
public static void main(String[] args)
{
method_zhtrim();
}
//转换-去空格
public static void method_zhtrim()
{
String s = " Hello Java ";
sop(s.toUpperCase()); //转大写
sop(s.toLowerCase()); //转小写
sop(s.trim());//去除两端的空格
}
//比较
public static void method_compareTo()
{
String s1 = "abc";
String s2 = "aaa";
sop(s1.compareTo(s2)); //比较ascii值s1>s2返回正数,小于s2返回负数,等于s2返回0
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
/*
字符串练习1:
模拟一个trim方法,去除字符串两端的空格
思路:
1.判断字符串第一个位置是否是空格,如果是继续向下判断,直到不是空格为止
结尾处判断空格也是如此.
2.当开始和结尾都判断到不是空格时,就是要获取的字符串
*/
class StringTestMainDemo1
{
public static void main(String[] args)
{
String s = " ab cd ";
sop("("+s+")");
s = myTrim(s);
sop("("+s+")");
}
public static String myTrim(String str)
{
int start = 0,end = str.length()-1;
while(start<=end && str.charAt(start)==' ')
start++;
while(start<=end && str.charAt(end)==' ')
end--;
return str.substring(start,end+1);
}
public static void sop(String str)
{
System.out.println(str);
}
}
/*
StringBuffer
字符串的组成原理就是通过该类实现的
StringBuffer可以对字符串内容进程增删
StringBuffer是一个容器
特点:
StringBuffer是可变长的
StringBuffer可以操作多个数据类型
StringBuffer最终会通过toString方法变成字符串
StringBuffer的功能:
1.存储
StringBuffer append(data) //将指定的数据作为参数添加到已有数据的结尾处
StringBUffer insert(index,data) //将指定的数据作为参数插入到已有数据的指定处
2.删除
StringBuffer delete(start,end) //删除缓冲区中的数据,包含start,不包含end
StringBuffer deleteCharAt(int index) //删除指定位置的字符
3.获取
char charAt(int index); //通过下标获取字符
int indexOf(String str); //根据字符获取下标
int lastIndexOf(String str); //从最后开始根据字符获取下标
int length(); //获取长度
String substring(int start,int end); //获取子串
4.修改
StringBuffer replace(int start,int end,String str);
void setCharAt(int index,char ch)
5.反转
StringBuffer reverse();
6.将缓冲区中指定数据存储到指定字符数组中
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
*/
class StringBufferMainDemo1
{
public static void main(String[] args)
{
method_add();
method_delete();
method_update();
method_getChars();
}
//添加
public static void method_add()
{
StringBuffer sb = new StringBuffer();
sb.append("abc").append(true).append(35).insert(1,"qq");
sop(sb.toString()); //abctrue35
/*
StringBuffer sb1 = sb.append(34);
sop(sb.toString());
sop(sb1.toString());
sop("sb==sb1:"+(sb==sb1)); //两个对象相等
*/
}
//删除
public static void method_delete()
{
StringBuffer sb = new StringBuffer("abcdef");
sb.delete(1,3);//adef 1是b d是3 不包含end所以,不包含d 那么只删除bc
sb.delete(0,sb.length()); //清空缓冲区
sb.deleteCharAt(2); //删除指定位置的字符
sop(sb.toString());
}
//修改
public static void method_update()
{
StringBuffer sb = new StringBuffer("abcdef");
sb.replace(1,4,"java"); //从1到4替换成Java
sb.setCharAt(2,'k'); //将2角标替换成k
}
//将缓冲区中指定数据存储到指定字符数组中
public static void method_getChars()
{
StringBuffer sb = new StringBuffer("abcdef");
char[] chs = new char[4];
sb.getChars(1,4,chs,1); //在sb对象中从1下标开始,到4下标结束,把数据插入到chs数组中,1下标开始的地方
for(int x =0; x<chs.length; x++)
{
sop("chs["+x+"]="+chs[x]+";");
}
}
public static void sop(String str)
{
System.out.println(str);
}
}
/*
在jdk1.5版本之后,出现了StringBuilder,不同处在于
StringBuffer是线程同步的
缺点,如果是单线程,会每次判断锁,所以效率不高
StringBuilder是线程不同步的
因此,单线程用StringBuilder,多线程用StringBuffer
以后开发建议使用StringBuilder
升级三个因素
1.提高效率
2.简化书写
3.提高安全性
*/
/*
基本数据类型对象包装类
byte//基本数据类型 Byte//引用数据类型
short//基本数据类型 Short//引用数据类型
int//基本数据类型 Integer//引用数据类型
long//基本数据类型 Long//引用数据类型
boolean//基本数据类型 Boolean//引用数据类型
double//基本数据类型 Double//引用数据类型
char//基本数据类型 Char//引用数据类型
基本数据类型对象包装类最常见的作用,就是用于
基本数据类型和字符串类型之间做转换
基本数据类型转成字符串
基本数据类型+""
基本数据类型.toString(基本数据类型值);
如: Integer.toString(34); //将34整数变成"34"
字符串转成基本数据类型
Integer.parseInt("123") //将字符串类型转换成int型
十进制转换成其他进制
toBinaryString();
toHexString();
toOctalString();
其他进制转换成十进制
parseInt(string,radix) //将指定的字符串转换成指定的进制表现形式,此方法是静态的
对象调用方式
Integer另一种表现形式
Integer i = new Integer("123");
int x = i.intValue(); //这个方法是静态的
*/
class IntegerMainDemo1
{
public static void main(String[] args)
{
//取整数类型的最大值
sop("int max :" + Integer.MAX_VALUE);
int num = Integer.parseInt("123");
sop("num+"(num+4)); //127
int x = Integer.parseInt("110",10); //将110转换成10进制
int x1 = Integer.parseInt("110",2); //将110转换成2进制
}
public static void sop(String str)
{
System.out.println(str);
}
}
class IntegerMainDemo2
{
public static void main(String[] args)
{
method();
//新特性
Integer x = 4; //自动装箱,帮你省略了new Integer(4),简化了书写
x = x + 2;//x+2:x进行了自动拆箱,变成了int类型,和2进行加法运算,再将和进行装箱赋给x
//那么它如何拆箱的呢?
x.intValue(); //拆箱原理
Integer m = 128;
Integer n = 128;
sop("m==n:"+(m==n)); //false
Integer a = 127;
Integer b = 127;
sop("m==n:"+(a==b)); //true,因为a和b指向了同一个Integer对象,因为当数值在byte范围内容
//对于新特性,如果该数值已经存在则不会在开辟新空间
}
public static void method()
{
Integer x = new Integer("123");
Integer y = new Integer(123);
sop("x==y:"+(x==y));
sop("x.equals(y):"+x.equals(y)); //这里equals比较的是数值是否相同
}
public static void sop(String str)
{
System.out.println(str);
}
}