黑马程序员---javaAPI笔记总结
String
String类使用来描述字符串的事物
那么他就提供了多个方法对字符串进行操作
常见的的操作有哪些？
获取：1、字符串中包含了字符数也就是字符串的长度
Int length（）；获取长度
2根据位置获取这个位置上的某个字符
Char charAt(int index)
3根据字符获取该字符的位置
Int indexof（int ch）;返回时ch在字符串中第一次出现的位置
Int intdexof（int ch ，int fromindex）从指定的索引开始搜索，返回在此字符串中第一次出现指定字符处的索引。
Int indexof（string str）;返回时str在字符串中第一次出现的位置
Int intdexof（string str ，int fromindex）从指定的索引开始搜索，返回在此字符串中第一次出现指定字符处的索引。
判断：字符串中是否包含一个字串
Boolean contains（str）判断字符串是否存在
特殊之处：indexof（str）可以索引第一次出现的位置，如果返回-1就表示str、
不存在，所以，也可以用于对指定判断是否包含
它们都可以做这些事
而却该方法既可以判断，又可以获取出现的位置
2.字符中是否有内容
3.Boolean isEmpty（）；就是判断长度是否为零
4.字符串是否是指定判断内容开头
5.Boolean startwith（str）
6.字符串是否是指定内容结尾
Boolean endswith（str）；
判断字符串的内容是否相同
Boolean equals（str）；
判断内容是否相同并胡烈大小写
Boolean equalsignorecase（）；
转换
1，将字符数组转成字符串
构造函数 string（char[]）
String (string ,offset,coutn);
将字符数组中的一部分转成字符串
public static void method()
{
char[] arr={'a','c','d','f','g','h','m','u'};
String a=new String(arr,4,3);
sop(a);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
2. 将字符串转换才字符数组
3.
将字节数组转成字符串
string（byte[]）
String (byte[],offset,coutn);
静态方法
Static string copValueOf（char[]）；
Static string copyvalueof（char[] data int offest int count）
Static string valueOf(char[]);
将 字符串转成字节数组
Byte[] getBytes(();
特殊
字符串和字节数组子啊转换过程中是指定编码表达
Char[] toCharArray();
静态方法 static string copyvalueof(valof)
替换
replace(char oldChar, char newChar)返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 而生成的。
切割
子串，获取字符串的一部分
String substring（begin，end）；包括头，但不包括尾部
转换 出去空格 比较
转换大小写 string touppercase（）大写
String tolowercase（）小写
除去空格 string trim（）；除去两边空格
对两个字符串进行自然数顺序的比较
比较 s1.compareto（s2）；比较
除去空格Trim的用法
class Stringtest
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
String s=" tt ter ";
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);//用substring返回一个子字符串
}
}
字符串反转
将字符串反转也就是将字符串倒起写出来
class Stringtest
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
String s=" dsgdfhgfhjuy6546756iun tt ter ";
sop("("+s+")");//打印先前的字符串
//s=mytrim(s);//打印截取的字符串
//sop("("+s+")");//打印截取的字符串
sop(reversestring(s));
}
//将字符串反转
//将字符串变成数组
//对数组反转
//将数组变成字符串
public static String reversestring(String s)
{//将字符串变成数组
char[] arr=s.toCharArray();//将字符串转成一个字符数组
//在反转数组
reverse(arr);
return new String(arr);
}
public static void reverse(char[] arr)
{
for(int start=0,end=arr.length-1;start<end;start++,end--)
{
change(arr,start,end);
}
}
public static void change(char[] arr,int x,int y)
{
char temp=arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
}
自定义字符串反转
class Stringtest
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
String s=" dsgdfhgr ";
sop("("+s+")");//打印先前的字符串
sop(reversestring(s,4,6));
}
//将字符串反转
//将字符串变成数组
//对数组反转
//将数组变成字符串
public static String reversestring(String s,int start,int end)
{//将字符串变成数组
char[] arr=s.toCharArray();//将字符串转成一个字符数组
//在反转数组
reverses(arr,start,end);
return new String(arr);
}
public static String reversestring(String s)
{
return reversestring(s,0,s.length());
}
反转自定义的字符
public static void reverses(char[] arr,int x,int y)
{
for(int start=x,end=y-1;start<end;start++,end--)
{
change(arr,start,end);
}
}
public static void reverse(char[] arr)
{
for(int start=0,end=arr.length-1;start<end;start++,end--)
{
change(arr,start,end);
}
}
public static void change(char[] arr,int x,int y)
{
char temp=arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
}
获取一个字符串在另一个字符串的位置(截取字符串)
class Substringtest
{
//第一次
public static int getsubcount(String arr,String key)
{
int count=0;
int index=0;
while((index=arr.indexOf(key))!=-1)
{
sop(arr);
arr=arr.substring(index+key.length());
count++;
}
return count;
}
//第二次
public static int getsubcount2(String arr,String key)
{
int count=0;
int index=0;
while((index=arr.indexOf(key,index))!=-1)
{
//sop("index="+index);
//arr=arr.substring(index+key.length());
index=index+key.length();
count++;
}
return count;
}
public static void main(String[] args)
{
String str="dfasdgfdsgdddddfdsfdfdsfsdfd";
sop(""+getsubcount2(str,"df"));//必须要转成字符串
}
public static void sop(String str)
{
System.out.println(str);
}
}
获取两个字符串中的最大相同的子串
class Stringtest2
{
public static String maxsubstr(String s1,String s2)
{
String max="",min="";
max=(s1.length()<s2.length())?s2:s1;
min=(max==s1)?s2:s1;
for (int x=0;x<min.length();x++ )
{
for(int y=0,z=min.length()-x;z!=min.length()+1;y++,z++)
{
String temp=min.substring(y,z);
//if(str1.contains(temp))
//return temp;
if(max.indexOf(temp)!=-1)
return temp;
}
}
return "";
}
public static void main(String[] args)
{
String s1="fdsfhadshelldfadsfadsf";
String s2="dsgdsgdfgdfhellsddpppp";
sop(maxsubstr(s1,s2));
}
public static void sop(String str)
{
System.out.println(str);
}
}
StringBuffer
/*
stringbuffer是字符串的缓冲区
是一个容器
特点
1而去长度是可以变化的
2可以直接操作多个数据
3最终会通过toString方法变成字符串
CURD
create update read delete
1，存储
Stringbuffer append() ;技术巨大 作为参数添加到已有数据结尾处
stringbuffe insert(index, 数据)；可以再指定位置插入数据
2 删除
delete(int start, int end)
移除此序列的子字符串中的字符。
deleteCharAt(int index)
移除此序列指定位置的 char。
获取
String substring(int start)
char charAt(int index) 返回此序列中指定索引处的 char 值。
int lastIndexOf(String str, int fromIndex) 返回最后一次出现的指定子字符串在此字符串中的索引。
lastIndexOf(String str)
返回最右边出现的指定子字符串在此字符串中的索引。
修改
StringBuffer replace(int start, int end, String str) 使用给定 String 中的字符替换此序列的子字符串中的字符。
void setCharAt(int index, char ch) 将给定索引处的字符设置为 ch。 只能替换一个
===========================
将缓冲区的指定字符存储在指定的字符数组中
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
将字符从此序列复制到目标字符数组 dst。
*/
class Stringbuffer
{
public static void main(String[] args)
{
//update();
StringBuffer s=new StringBuffer("dfdfdsg");
sop(s.toString());
char[] ch=new char[6];//创建一个char数组
s.getChars(1,4,ch,1);
for (int x=0;x<ch.length;x++ )
{
sop("ch["+x+"]="+ch[x]+";");
}
}
public static void update()
{
StringBuffer s=new StringBuffer("dfdfdsg");
sop(s.toString());
//s.replace(2,3,"java");
//s.setCharAt(1,'j');
s.reverse();
sop(s.toString());
}
public static void del()
{
StringBuffer s=new StringBuffer("dfdfdsg");
sop(s.toString());
//这叫清空缓冲区
//s.delete(0,s.length());
//s.delete(2,3);
s.deleteCharAt(3);
sop(s.toString());
}
public static void add()
{
StringBuffer s=new StringBuffer();
s.append("dfdgdfgf").append(false).append("dfdf").append(true);
s.insert(2,"ddd");
sop(s.toString());
}
public static void sop(String str)
{
System.out.println(str);
}
}
JDK1，5版本之后出现了stringbuilder
StringBuffer是线程同步的 安全的 建议在多线程使用
Stringbuilder是线程不同步的 建议在单线程使用
以后开发建议使用builder
升级三个因素：
1提高速率，
2简写代码
3提高安全性
基本数据类型对象包装类
最常见的作用是用于基本数据类型和字符串类型之间做转换
基本数据类型转字符串
基本数据类型+“”；
基本数据类型,tosrting(j基本数据类型值)
如
Integer.toString(34);将34转成“34”；
字符串转成基本数据类型
/*
这些都是静态的
字符串转成基本数据类型
int a=Integer.parseInt();
boolean bb=Boolean.parseBoolean();
toBinaryString(int i)
以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。
toHexString(int i)
以十六进制的无符号整数形式返回一个整数参数的字符串表示形式。
toOctalString(int i)
以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。
十进制转成其他进制
toBinaryString(int i)
toHexString(int i)
toOctalString(int i)
其他进制转成十进制
Integer.parseInt("110",2);//将字符串110转成二进制
Integer.parseInt("3c",16);//将字符串3c转成十六进制
====
//Integer是整数数据类型int的封装类
还有一个非静态的intValue（）
Integer i=new Integer("45654654");
sop(""+i.intValue());
*/
class Integerdemo
{
public static void main(String[] args)
{
int a=Integer.parseInt("545");
sop(Integer.toBinaryString(-6));
sop(Integer.toHexString(60));
sop("----");
sop(""+Integer.parseInt("3c",16));
Integer i=new Integer("45654654");
sop(""+i.intValue());
}
public static void sop(String str)
{
System.out.println(str);
}
}
基本数据类型的 对象包装新特性
/*
基本数据类型的 对象包装新特性
*/
class Integerdemo2
{
public static void main(String[] args)
{
//Integer x=4;//自动装箱
//x=x+2;//自动拆箱 变成int在相加 在装箱 在赋给x
Integer m=128;
Integer n=128;
sop("n=m:"+(n==m));
Integer a=127;
Integer b=127;
sop("a=b:"+(a==b));//结果为true 因为a和b指向同一integer对象
//因为但数值在byte范围内对于新特性如果该数值已存在，则不会开辟新的空间
//因为byte的范围在-128~127之间
}
public static void method()
{
Integer in=new Integer("123");
Integer ad=new Integer(123);
sop("in==ad:"+(in==ad));
sop("in.equals:"+(in.equals(ad)));
}
public static void sop(String str)
{
System.out.println(str);
}
}
集合转成数组
为什么要集合变成数组，是为了限定对元素的操作，不能进行增删了
import java.util.*;
class Collectiontoarray
{
public static void main(String[] args)
{
List<String> list=new ArrayList<String>();
list.add("abc1");
list.add("abc2");
list.add("abc5");
list.add("abc3");
/*
指定类型的数组要定义多长呢？
当指定类型的数组长度小于集合的size，那么该方法的内部会创建一个新的数组，长度为集合
当指定类的数组长度大于集合的size，不会新创建数组，而回使用传递进来的数组，所以创建一个刚刚好的数组是最好的*/
String[] arr=list.toArray(new String[1]);
System.out.println(Arrays.toString(arr));
}
}
高级for循环
import java.util.*;
class Fordemo
{
public static void main(String[] args)
{
HashMap<String,Integer> hm=new HashMap<String,Integer>();
hm.put("12",4);
hm.put("13",5);
hm.put("14",6);
hm.put("15",7);
hm.put("16",8);
for (Map.Entry<String,Integer> me:hm.entrySet() )
{
System.out.println(me.getKey()+"----"+me.getValue());
}
}
}
集合中的可变参数
注意，可变参数一定要定义在参数的最后面
class ParamShow
{
public static void main(String[] args)
{
show(1,2,4,879,56,6,6,7);
}
public static void show(int...arr)
{
System.out.println(arr.length);
}
}
静态导入
当类名重名是要指定具体的包名
当方法重名是要指定具备所属的对象或类
Collections中的替换 和反转
import java.util.*;
class Filldemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
fll();
}
public static void fll()
{
List<String> ls=new ArrayList<String>();
ls.add("aa");
ls.add("eop");
ls.add("coi");
ls.add("jeghtuhh");
ls.add("ddgf");
ls.add("b");
ls.add("b");
ls.add("coi");
sop(ls);
Collections.replaceAll(ls,"b","ooo");
sop(ls);
Collections.reverse(ls);
sop(ls);
}
}
reverseOrder(Comparator<T> cmp)
返回一个比较器，它强行反转指定比较器的顺序。如果指定比较器为 null，则此方法等同于 reverseOrder()（换句话说，它返回一个比较器，该比较器将强行反转实现 Comparable 接口那些对象 collection 上的自然顺序）。
import java.util.*;
class Reverseorder
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
reverseOrder();
}
public static void reverseOrder()
{
TreeSet<String> ls=new TreeSet<String>(Collections.reverseOrder(new Comparator<String>(){
public int compare(String str1,String str2)
{
if(str1.length()<str2.length())
return -1;
if(str1.length()>str2.length())
return 1;
return str1.compareTo(str2);
}
}));
ls.add("aa");
ls.add("eop");
ls.add("coi");
ls.add("jeghtuhh");
ls.add("ddgf");
ls.add("b");
ls.add("b");
ls.add("coi");
sop(ls);
}
}
Shufflee(List<?> list)使用默认随机源随机更改指定列表的序列。
玩扑克牌和色子必用方法
import java.util.*;
class Filldemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
fll();
}
public static void fll()
{
List<String> ls=new ArrayList<String>();
ls.add("aa");
ls.add("eop");
ls.add("coi");
ls.add("jeghtuhh");
ls.add("ddgf");
ls.add("b");
ls.add("b");
ls.add("coi");
Collections.shuffle(ls);
sop(ls);
}
}
Collections-sort的用法
import java.util.*;
class Collectionssort
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
sort();
}
public static void sort()
{
List<String> ls=new ArrayList<String>();
ls.add("aa");
ls.add("eop");
ls.add("coi");
ls.add("jeghtuhh");
ls.add("ddgf");
ls.add("b");
ls.add("coi");
ls.add("jeghtuhh");
ls.add("ddgf");
ls.add("b");
ls.add("fkki");
sop(ls);
Collections.sort(ls,new Comparator<String>(){
public int compare(String str1,String str2)
{
if(str1.length()<str2.length())
return -1;
if(str1.length()>str2.length())
return 1;
return str1.compareTo(str2);
}
});
sop(ls);
}
}
Fill可以将集合中的所有元素替换成所有元素
import java.util.*;
class Filldemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
fll();
}
public static void fll()
{
List<String> ls=new ArrayList<String>();
ls.add("aa");
ls.add("eop");
ls.add("coi");
ls.add("jeghtuhh");
ls.add("ddgf");
ls.add("b");
ls.add("b");
ls.add("coi");
sop(ls);
Collections.fill(ls,"pp");
sop(ls);
}
}
Collections中的替换 和反转
import java.util.*;
class Filldemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
fll();
}
public static void fll()
{
List<String> ls=new ArrayList<String>();
ls.add("aa");
ls.add("eop");
ls.add("coi");
ls.add("jeghtuhh");
ls.add("ddgf");
ls.add("b");
ls.add("b");
ls.add("coi");
sop(ls);
Collections.replaceAll(ls,"b","ooo");
sop(ls);
Collections.reverse(ls);
sop(ls);
}
}
reverseOrder(Comparator<T> cmp)
返回一个比较器，它强行反转指定比较器的顺序。如果指定比较器为 null，则此方法等同于 reverseOrder()（换句话说，它返回一个比较器，该比较器将强行反转实现 Comparable 接口那些对象 collection 上的自然顺序）。
import java.util.*;
class Reverseorder
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
reverseOrder();
}
public static void reverseOrder()
{
TreeSet<String> ls=new TreeSet<String>(Collections.reverseOrder(new Comparator<String>(){
public int compare(String str1,String str2)
{
if(str1.length()<str2.length())
return -1;
if(str1.length()>str2.length())
return 1;
return str1.compareTo(str2);
}
}));
ls.add("aa");
ls.add("eop");
ls.add("coi");
ls.add("jeghtuhh");
ls.add("ddgf");
ls.add("b");
ls.add("b");
ls.add("coi");
sop(ls);
}
}
Shufflee(List<?> list)使用默认随机源随机更改指定列表的序列。
玩扑克牌和色子必用方法
import java.util.*;
class Filldemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
fll();
}
public static void fll()
{
List<String> ls=new ArrayList<String>();
ls.add("aa");
ls.add("eop");
ls.add("coi");
ls.add("jeghtuhh");
ls.add("ddgf");
ls.add("b");
ls.add("b");
ls.add("coi");
Collections.shuffle(ls);
sop(ls);
}
}
Arrays
asList(T... a)返回一个受指定数组支持的固定大小的列表。
就是将数组变成集合
import java.util.*;
class Arraysdemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
/*
把数组变成集合的好处就是用集合的方法来操作数组
注意将数组变成集合不可以使用集合的增删方法，因为数组长度是固定的
如果增删会发生操作异常
*/
//System.out.println(Arrays.toString(dd));
String[] arr={"fdg","hh","aa","bb","ff"};
List<String> list=Arrays.asList(arr);
Integer[] dd={1,32,4,5,9};
/*
如果数组中的元素都是对象，那么变成集合时，数组元素，都直接转成集合中的元素
如果是基本数据类型，那么将该数组作为集合中的元素存在
*/
List<Integer> list1=Arrays.asList(dd);
sop(list1);
}
}
