------ ASP.Net+Android+IO开发.Net培训期待与您交流! ------
总结内容来源于黑马毕老师的java基础教学视频
String类
String类特点:是一个特殊的类,定义时被final修饰,所以它没有子类,字符串一旦初始化,就不可以被改变.
- class StringDemo
- {
- public static void main(String[] args)
- {
- String s1 = "abc";//s1是一个类类型变量,"abc"是一个对象.
- //字符串最大的特点:一旦被初始化就不可以被改变.
- String s2 = new String("abc");
- //s1和s2有什么区别?
- //s1在内存中有一个对象. "abc".
- //s2在内存中有两个对象. new String()和"abc".
- System.out.println(s1==s2);//结果为false
- System.out.println(s1.equals(s2));//结果为true
- //原因是String类复写了Object类中的equals方法.
- //该方法用于判断字符串是否相同.
- }
- }
String类是用于描述字符串事物.
那么它就提供了多个方法对字符串进行操作.
常见的操作有哪些?
1.获取
1.1 字符串中的包含的字符数,也就是长度.
int length():获取长度
1.2 根据位置获取位置上的某个字符.
char charAt(int index)
1.3 根据字符获取该字符在字符串中的位置
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,表示不在字符串中存在.
所以,也可以用于对指定判断是否包含.
if(str.indexOf("aa")!=-1);//判断写法
而且该方法既可以判断,又可以获取出现的位置.
2.2 字符中是否有内容.
boolean isEmpty();//原理就是判断长度是否为0
2.3 字符串是否以指定内容开头.
boolean startsWith(String str);
2.4 字符串是否是以指定内容结尾.
boolean endsWith(String str);
2.5 判断字符串的内容是否相同.复写了Object类中的equals方法
boolean equals(str);
2.6 判断内容是否相同,并忽略大小写.
boolean equalsIgnoreCase();
3.转换.
3.1 将字符数组转成字符串.
构造函数:new String(char[])
new String(char[],offset,count)//将字符数组中的一部分转成字符串
静态方法:
static String copyValueOf(char[])
static String copyValueOf(char[] data, int offset, int count)
static String valueOf(char[])
3.2 将字符串转成字符数组.
char[] toCharArray()
3.3 将字节数组转成字符串.
new String(byte[])
new String(byte[],offset,count):将字节数组中的一部分转成字符串
3.4 将字符串转成字节数组.
byte[] getBytes()
3.5 将基本数据类型转成字符串.
static String valueOf(int)
static String valueOf(double)
例如 3+""和String.valueOf(3)的效果是相同的.
特殊:字符串和字节数组在转换过程中,是可以指定编码表的.
4.替换
返回一个新的字符串,它是通过用newChar替换此字符串中出现的所有 oldChar得到的
String replace(oldChar, newChar)
使用指定的字符串new替换指定的字符串old,也返回一个新的字符串.
String replace(oldString, newString)
5.切割
根据给定表达式的匹配拆分此字符串。
String[] split(regex)
6.子串.获取字符串中的一部分
从指定位置开始到结尾
String substring(begin)
返回一个新字符串,该字符串的长度为 end-begin.
String substring(begin,end);
7.转换,去除空格,比较
7.1 将字符串转成大小写.
String toUpperCase()
String toLowerCase()
7.2 将字符串两端多个空格去除.
String trim();
7.3 对两个字符串进行比较,该比较基于字符串中各个字符的Unicode值.
int compareTo(string)
- class StringMethodDemo
- {
- public static void method_7()
- {
- String s = " Hello Java ";
- sop(s.toUpperCase());
- sop(s.toLowerCase());
- sop(s.trim());
- String s1 = "a1c";
- String s2 = "aaa";
- sop(s1.compareTo(s2));
- sop("---------------------------------------------------");
- }
- public static void method_sub()
- {
- String s = "abcdef";
- sop(s.substring(3));
- sop(s.substring(3,5));
- sop("---------------------------------------------------");
- }
- public static void method_slipt()
- {
- String s = "zhangsan,lisi,wangwu";
- String[] s1 = s.split(",");
- for (int x=0; x<s1.length; x++)
- {
- sop(s1[x]);
- }
- sop("---------------------------------------------------");
- }
- public static void method_replace()
- {
- String s = "hello java";
- //String s1 = s.replace('q','n');
- //如果要替换的字符不存在,返回原串
- String s1 = s.replace("java","world");
- sop("s="+s);
- sop("s1="+s1);
- }
- public static void method_trans()
- {
- char[] arr = {'a','b','c','d','e'};
- //用构造函数将字符数组转成字符串
- String s =new String(arr,1,3);
- sop("s="+s);
- //用静态方法将字符数组转成字符串
- sop(String.copyValueOf(arr,3,2));
- String s1 = "gesfedghe";
- //将字符串转成字符数组
- char[] arr1 = s1.toCharArray();
- for (int x= 0; x<arr1.length; x++)
- {
- if (x==arr1.length-1)
- {
- System.out.print(arr1[x]+"]");
- }
- else if (x==0)
- {
- System.out.print("["+arr1[x]+",");
- }
- else
- System.out.print(arr1[x]+",");
- }
- }
- public static void method_is()
- {
- String str = "ArrayDemo.java";
- //判断文件名是否是是Array单词开头.
- sop(str.startsWith("Array"));
- //判断文件名是否是.java的文件.
- sop(str.endsWith(".java"));
- //判断文件中是否包含Demo
- sop(str.contains("Demo"));
- sop("---------------------------------------------------");
- }
- public static void method_get()
- {
- String str = "abcdefakpf";
- //获取字符串长度
- sop("length="+str.length());
- //根据索引获取字符
- sop(str.charAt(4));//当访问到字符串中不存在的角标时会发生:
- //StringIndexOutOfBoundsException(字符串角标越界)
- //根据字符获取索引
- sop(str.indexOf('a',3));//如果没有找到,返回-1.
- //根据字符串获取索引
- sop(str.indexOf("de"));
- //反向索引一个字符出现位置.
- sop(str.lastIndexOf("a"));
- sop("---------------------------------------------------");
- }
- public static void main(String[] args)
- {
- method_get();
- //method_is();
- //method_trans();
- //method_replace();
- //method_slipt();
- //method_sub();
- //method_7();
- /*
- String s1 = "abc"';
- String s2 = new String("abc");
- System.out.println("Hello World!");
- */
- }
- public static void sop(Object obj)
- {
- System.out.println(obj);
- }
- }
String练习
- /*
- 一:模拟一个trim方法,去除字符串两端的空格.
- 思路:
- 1.判断字符串第一个位置是否空格,如果是继续向下判断,
- 直到不是空格为止,结尾处判断空格也是如此.
- 2.当开始和结尾都判断到不是空格时,就要获取的字符串.
- 二:将一个字符串进行反转,将字符串中指定部分进行反转,"abcdefg",abfedcg
- 思路:
- 1.曾经学习过对数组的元素进行反转.
- 2.将字符串变成数组,对数组反转.
- 3.将反转后的数组变成字符串.
- 4.只要将要反转的部分的开始和结束为止作为参数传递即可.
- 三:获取一个字符串中另一个字符转中出现的次数.
- "abkkcdkkefkkskk"
- 思路:
- 1.定义个计数器.
- 2.获取kk第一次出现的位置.
- 3.从第一次出现位置后剩余的字符串中继续获取kk出现的位置.
- 每获取一次,就计数一次.
- 4.当获取不到时,计数完成.
- 四:获取两个字符串中最大相同子串.第一个动作:将短的串进行长度一次递减
- 的子串打印
- "abcwerthelloyuiodef"
- "cvhellobnm"
- 思路:
- 1.将短的子串按照长度递减的方式获取到.
- 2.将每次获取到的子串去长串中判断是否包含,如果包含,已经找到!
- */
- class Trim
- {
- //打印的简写调用方法
- public void sop(Object obj)
- {
- System.out.println(obj);
- }
- //练习四
- public void getContainsSub(String str,String key)
- {
- String max = "",min = "";
- max = (str.length()>key.length())?str:key;
- min = (max==str)?key:str;
- for (int y=min.length();y>0 ;y-- )
- {
- int x = 0;
- int temp = y;
- while(temp!=min.length()+1)
- {
- String s = min.substring(x,temp);
- if(max.contains(s))
- {
- sop(s);
- return;
- }
- x++;
- temp++;
- }
- }
- }
- //练习三:方式二
- public void samMethod1(String str,String key)
- {
- int count = 0;
- int index = 0;
- while ((index=str.indexOf(key,index))!=-1)
- {
- index = index + key.length();
- count ++;
- }
- sop(count);
- }
- //练习三:方式一
- public void samMethod(String str,String key)
- {
- int count = 0;
- int index = 0;
- if(str.contains(key))
- {
- while ((index=str.indexOf(key))!=-1)
- {
- sop(str);
- str = str.substring(index+key.length());
- count ++;
- }
- sop(count);
- }
- }
- //练习二
- public void turnMethod(String str,int x,int y)
- {
- //字符串变char数组
- char[] c = str.toCharArray();
- //反转数组
- while (x<y)
- {
- char temp = c[x];
- c[x] = c[y];
- c[y] = temp;
- x++;
- y--;
- }
- //将数组变字符串
- String s = new String(c);
- sop(s);
- }
- //练习一
- public void trimMethod(String str)
- {
- int x = 0;
- int y = str.length()-1;
- while (str.charAt(x)==' '&&x<y)
- {
- x++;
- }
- while (str.charAt(y)==' '&&y>0)
- {
- y--;
- }
- if(x>y)
- sop("你输入的字符串无效");
- else
- sop(str.substring(x,y+1));
- }
- }
- class StringTest
- {
- public static void main(String[] args)
- {
- String s = "abcdefg";
- Trim t = new Trim();
- //t.trimMethod(s);
- //t.turnMethod(s,4,6);
- //t.samMethod1("abkkcdkkefkkskk","kk");
- t.getContainsSub("cvhellobnm","abcwerthelloyuiodef");
- }
- }
StringBuffer是字符串缓冲区.
是一个容器.特点:
1.长度是可变化的
2.可以直接操作多个数组类型.
3.最终会通过toString变成字符串.
1.存储
StringBuffer append();将制定数据作为参数添加到已有数据的结尾处.
StringBeffer insert(index,数据):可以将数据插入到制定index位置.
2.删除
StringBuffer delete(start,end):删除缓冲区数据,包含start,不包含end.
StringBuffer deleteCharAt(index):删除指定位置的字符.
3.获取.
char charAt(index)
int indexOf(str)
int lastIndexOf(str)
int length()
String substring(start,end)
4.修改
StringBuffer replace(start,end,String)替换start到end的字符串
void setCharAt(index,char)替换某角标位的字符
5.反转
StringBuffer reverse()
6.
将缓冲区指定数组存储到指定char[]中.
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
- class StringBufferDemo
- {
- public static void main(String[] args)
- {
- // method_del();
- method_update();
- }
- public static void method_update()
- {
- StringBuffer sb = new StringBuffer("avdeyswj");
- sb.replace(1,7,"java");
- sb.setCharAt(5,'a');
- sop(sb.toString());
- }
- public static void method_del()
- {
- StringBuffer sb = new StringBuffer("avdeyswj");
- // sb.delete(2,7);
- //清除缓冲区
- sb.delete(0,sb.length());
- sop(sb.toString());
- }
- public static void method_add()
- {
- StringBuffer sb = new StringBuffer();
- sb.append(34).append(true).append("abc");
- sb.insert(3,"pp");
- sop(sb.toString());
- }
- public static void sop(String str)
- {
- System.out.println(str);
- }
- }
Dk1.5版本之后出现了StringBuilder.
StringBuffer是线程同步.自带锁,同时只能有一个线程操作,建议多线程使用
StringBuilder是线程不同步.无锁,建议单线程使用.
以后开发建议使用StringBuilder.
JDK升级三个因素
1.提高安全性
2.提高效率
3.简化书写
byte Byte
short Short
int Integer
long Long
boolean Boolean
float Float
double Double
char Character
基本数据类型对象包装类的最常见作用:
就是用于基本数据类型和字符串类型之间做转换
基本数据类型转成字符串.
基本数据类型+"";
基本数据类型.toString(基本数据类型值);
如:Integer.toString(34);//将34整数变成"34".
字符串转成基本数据类型.
静态方法转换
xxx a = Xxx.parseXxx(String);
int a = Integer.parseInt("123");
double d = Double.parseDouble("12.23");
boolean b = Boolean.parseBoolean("true");
对象调用方法
Integer i = new Integer("123")
int i = i.intValue();
十进制转成其他进制.
toBinaryString(十进制数字);//转成二进制
toHexString(十进制数字);//转成十六进制
toOctalString(十进制数字);//转成八进制
其他进制转成十进制.
parseInt(string,radix)
parseInt("3c",16)
parseInt("110",2)
parseInt("77",8)
- /*
- JDK1.5版本以后出现的新特性.
- */
- class IntegerDemo1
- {
- public static void main(String[] args)
- {
- // Integer x = new Integer(4);
- Integer x = 4;//和上面的意义是相同的,进行了自动装箱.
- x = x + 2;//x进行了自动拆箱,变成了int型,和2进行加法运算.
- //再将运算结果进行装箱赋给X.
- Integer m = 128;
- Integer n = 128;
- sop("m==n"+(m==n));//结果为假,两个对象
- Integer a = 127;
- Integer b = 127;
- sop("a==b"+(a==b));//结果为真:
- //因为a和b指向了同一个Integer对象.
- //因为当数字在byte范围内时,由于新特性,
- //如该值已存在,不会开辟新空间.
- }
- }