------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流! ----------
JAVA_API
String类
字符串是一个特殊的对象。
字符串一旦初始化就不可以被改变。
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,表示str不在该字符串中存在
if(str.indexOf("aa")!=-1)
该方法既可以判断,又可以获取出现的位置
2.2 字符串中是否有内容
boolean isEmpty(); 判断长度是否为零:"" null
2.3 字符串是否以指定内容开头
boolean startsWith(str);
2.4 字符串是否以指定位置结尾
boolean endsWith(str);
2.5 判断字符串内容是否相同。复习了Object类中的equals方法
boolean equals(str);
2.6 判断内容是否相同,并忽略大小写
boolean equalsIgnoreCase(str);
3,转换
3.1 将字符数组转换成字符串
构造函数:String(char[])
String (char[], offset, count)将字符数组中的一部分转换成字符串
静态方法:
static String copyValueOf(char[]);
static String copyValueOf(char[] data, int offset , int count);
3.2 将字符串转换成字符数组
char[] toCharArray();
3.3 将字节数组转换成字符串
String(char[])
String (char[], offset, count)将字符数组中的一部分转换成字符串
3.4 将字符串转成字节数组
byte[] getBytes();
3.5 将基本数据类型转换成字符串
String valueOf(int);
String valueOf(double);
3+""; //String valueOf(3);
特殊:字符串和字节数组在转换过程中,是可以指定编码表的
4,替换
String replace(oldchar , newchar);
5,切割
String[] split(regex);
6,字串。获取字符串中的一部分
String substring(begin);
String substring(begin,end);
7,转换,去除空格,比较
7.1 将字符串转换成大写或小写
String toUppercase();
String toLowercase();
7.2 将字符串两端的多个空格去掉
String trim();
7.3 对两个字符串进行自然顺序的比较
int copmpareTo(String);
字符串操作演示
package StringMethodDemo;
class StringMethodDemo
{
public static void method_7()
{
String s = " Hello Java ";
sop(s.toUpperCase());
sop(s.toLowerCase());
sop(s.trim());
String s1 = "aef";
String s2 = "aaa";
sop(s1.compareTo(s2));
}
//求字串的函数
public static void method_substring()
{
String s = "abcdef";
sop(s.substring(2));//从指定位置到结尾
sop(s.substring(2,4)); //包含头,不包含尾
}
//字符串切割的函数
public static void method_split()
{
String s = "zhangsanxxlisixxwangwu";
String[] arr = s.split("xx"); //用xx作为标记来切割
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');//如果替换的字符不存在,返回的是原字符串
String s1 = s.replace("java","world"); //转换后产生了一个新字符串
sop("s="+s);
sop("s1="+s1);
}
//字符串转换的函数
public static void method_trans()
{
char[] arr = {'a','b','c','d','e','f'};
String s = new String(arr); //使用构造函数转换
sop("s= "+s);
String s1 = "abcsdssalsad";
char[] chs = s1.toCharArray(); //将字符串s1转换成字符数组
//循环打印字符数组中的每个元素
for( int x=0; x<chs.length; x++)
{
sop("chs="+chs[x]);
}
}
//字符串判断的函数
public static void method_is()
{
String str = "ArrayDemo.java";
sop(str.startsWith("Array")); //判断文件是否是Array单词开头
sop(str.endsWith("java")); //判断文件是否是.java文件
sop(str.contains("Demo")); //判断文件是否包含Demo
}
//字符串获取函数
public static void method_get()
{
String str = "abcdaef"; //定义一个字符串
sop(str.length()); //打印字符串的长度
//当访问到字符串中不存在的下标时,会出现StringIndexOutOfBoundException
sop(str.charAt(4)); //根据索引获取字符
sop(str.indexOf('m',3));//根据字符获取索引,如果没有找到返回-1
sop(str.lastIndexOf("a"));//反向索引一个字符串出现的位置
}
public static void main(String[] args)
{
method_get();
method_is();
method_trans();
method_replace();
method_split();
method_substring();
method_7();
/*
String s1 = "abc";
String s2 = new String("abc");
String s3 = "abc";
System.out.println(s1==s2);
System.out.println(s1==s3);
*/
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
字符串的练习:
1,模拟一个trim方法,去除字符串两端的空格
思路:
1 判断字符串第一个位置是否是空格,如果是继续向下判断,直到不是空格为止
结尾处判断空格也是如此
2 当开始和结尾都判断不是空格时,就是要获取的字符串
2,将一个字符串进行反转。将字符串指定的部分进行反转
思路:
1 曾经学习过对数组的元素进行反转
2 将字符串变成数组,对数组反转
3 将反转后的数组变成字符串
4 只要将被反转的部分开始和结束的位置作为参数传递即可
3,获取一个字符串在另一个字符串中出现的次数
"dsjdooaddddooisqoo"
思路:
1 定义个计数器
2 获取oo第一次出现的位置
3 从第一次出现位置后剩余的字符串中继续获取oo出现的位置
每获取一次就计数一次
4 当获取不到时,计数完成
4,获取两个字符串中最大相同字串。第一个动作:将短的那个串进行长度依次递减的字串打印
思路:
1 将短的那个字串按照长度递减的方式获取到
2 将每获取到的字串去长串中判断是否包含
如果包含,已经找到
代码演示:
package StringTest;
class StringTest
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
String s = " abc def ";
sop("("+s+")");
//s = my_trim(s);
//sop("("+s+")");
sop("("+reverseString(s,6,9)+")");
String str = "dsjdooaddddooisqoo";
sop("count "+getSubCount_2(str,"oo"));
String s1 = "shiciahellosdasdad";
String s2 = "sjoahellosa";
sop(getMaxSubString(s1,s2));
}
//练习一:去除字符串两端的空格
public static String my_trim(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 String reverseString(String str, int start, int end)
{
//将字符串转换成字符数组
char[] chs = str.toCharArray();
//反转数组
reverse(chs,start,end);
//数组变成字符串
return new String(chs);
}
public static String reverseString(String str)
{
return reverseString(str,0,str.length());
}
private static void reverse(char[] arr,int x, int y) //字符数组反转函数
{
for( int start=x,end=y-1; start<end; start++,end--) //一般包含头不包含尾,y-1
{
swap(arr,start,end);
}
}
private static void swap(char[] arr, int x, int y) //交换函数
{
char temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
//练习三
public static int getSubCount_1(String str,String key)
{
int count = 0; //定义计数器
int index = 0; //记录key第一次出现的位置
while((index=str.indexOf(key))!=-1)
{
sop("str= "+str);
str = str.substring(index+key.length()); //依次返回key后边的子串
count++; //计数器自增
}
return count;
}
//练习三:方式二
public static int getSubCount_2(String str,String key)
{
int count = 0;
int index = 0;
while((index=str.indexOf(key,index))!=-1)//从指定位置开始判断
{
index = index+key.length();
count++;
}
return count;
}
//练习四
public static String getMaxSubString(String s1,String s2)
{
//求短的字符串
String max="",min="";
max = (s1.length()>s2.length())? s1:s2;
min = (max==s1)? s2 : s1;
sop("max= "+max+" min= "+min);
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(max.contains(temp))// if(max.indexOf(temp)!=-1)
return temp;
}
return "";
}
}
StringBuffer
是一个容器
特点:
1 而且长度是可变化的
2 可以直接操作多个数据类型
3 最终会通过toString()方法变成字符串
C create U update R read D delete
1,存储
StringBuffer append() :将制定数据作为参数添加到已有数据结尾处
StringBuffer insert(index,数据) :可以将数据插入到制定index位置
2,删除
StringBuffer delete(start,end)删除缓冲区中的数据,包含start,不包含end
StringBuffer deleteCharAt(index)删除指定位置的字符
3,获取
4,修改
StringBuffer replace(start,end,String);
StringBuffer setCharAt(int index,char ch);
5,反转
StringBuffer reverse();
6,将缓冲区中指定数据存储到制定数组中
void getchas(int srcBegin, int srcEnd, char[] dst, int dstBegin);
JDK 1.5 版本之后出现了StringBuilder
StringBuffer是线程同步
StringBuilder是线程不同步。//不用判断锁,单线程运行比较快捷
以后开发,建议使用StringBuilder
升级三个因素:
1,提高效率
2,简化书写
3,提高安全性
代码演示:
package StringBuffer;
class StringBufferDemo
{
public static void main(String[] args)
{
method_del();
method_update();
StringBuffer sb = new StringBuffer("abcdef");
char[] chs = new char[4];
sb.getChars(1,4,chs,1); //将字符串1~3的字符复制到chs中从1开始的位置
for(int x=0; x<chs.length; x++)
{
//依次打印字符数组chs中的字符
sop("chs["+x+"]="+chs[x]);
}
}
//字符串替换的函数
public static void method_update()
{
StringBuffer sb = new StringBuffer("abcde");
sb.replace(1,4,"java"); //将从下标为1到4(不包含)的字符替换为"java"
sb.setCharAt(2,'k'); //将索引为2处的字符替换为k
sop(sb.toString()); //打印字符串
}
public static void method_del()
{
StringBuffer sb = new StringBuffer("abcde");
sb.delete(1,3); //移除从索引1开始到索引(3-1)处的字符
sop(sb.toString());
sb.delete(0,sb.length()); //清空缓冲区
sop(sb.toString());
}
public static void method_add()
{
StringBuffer sb = new StringBuffer(); //定义一个缓冲区
sb.append("abc").append(true);//不断地在末尾添加数据,返回的是StringBuffer对象
sop(sb.toString());
sb.insert(1,"qq"); //在指定位置插入数据
sop(sb.toString());
}
public static void sop(String str)
{
System.out.println(str);
}
}
基本数据类型对象包装类
byte Byte
short short
int Integer
long Long
boolean Boolean
duble Double
char Character
基本数据类型对象包装类最常见作用:
就是用于基本数据类型和字符串类型之间做转换
基本数据类型转成字符串
基本数据类型+""
基本数据类型.toString(基本数据类型);
字符串转成基本数据类型
xxx a = Xxx.parseXxx(string);
int a = Integer.parseInt("123");
double d = Double.parseDouble("12.34");
boolean b = Boolean.parseBoolean("true");
十进制转换成其他进制
toBinaryString();
toHexString();
toOctalString();
其他进制转成十进制
parseInt(string s, int radix);
代码演示:
package IntegerDemo;
class IntegerDemo
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
//整数类型的最大值
sop("int max :"+Integer.MAX_VALUE);
//将一个字符串转成整数
int num = Integer.parseInt("123");
long x= Long.parseLong("123");
sop("num="+(num+4));
sop(Integer.toBinaryString(-6)); //将十进制转换成二进制
sop(Integer.toHexString(-6)); //将十进制转换成十六进制
int y = Integer.parseInt("110",2); //将二进制转换成十进制
sop("y = "+y);
Integer x = 4; //自动装箱
x = x+4; //进行自动拆箱,将x变成Int型,和4进行运算,再自动装箱
}
}
集合
List
Collection
|--List : 元素是有序的,元素可以重复。因为该集合体系有索引
|--ArrayList: 底层的数据结构使用的是数组结构。线程不同步
|--LinkedList: 底层的数据结构使用的是链表结构
|--Vector: 底层是数组数据结构。线程同步。被ArrayList替代了
|--Set :元素是无序,元素不可以重复
List:
特有方法:凡是可以操作角标的方法都是该体系特有的方法
增
add(index,element);
addAll(index,Collection);
删
remove(index);
改
set(index,element);
查
get(indx)
subList(from,to);
listIterator
ListIterator
List集合特有的迭代器。ListIterator是Iterator的子接口
在迭代时,不可以通过集合对象的方法操作集合中的元素
因为会发生ConcurrentModificationException异常
所以,在迭代时,只能用迭代器的方法操作元素,可是Iterator的方法是有限的
只能对元素进行判断、取出、删除的操作
如果想要其他的操作茹添加、修改等,就需要使用其子接口listIterator
该接口只能通过List集合的ListIterator方法获取
代码演示:
package ListDemo;
import java.util.*;
class ListDemo
{
public static void main(String[] args)
{
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
//演示列表迭代器
ListIterator li = al.listIterator();
while(li.hasNext())
{
Object obj = li.next();
if(obj.equals("java02"))
li.set("java006");
}
sop("hasNext:"+li.hasNext());
//逆向迭代列表,判断集合中是否还有元素
sop("hasPrevious:"+li.hasPrevious());
/*
//在迭代或删除过程中,准备添加或删除元素
Iterator it = al.iterator();
while(it.hasNext())
{
Object obj = it.next();
if(obj.equals("java01"))
//al.add("java008"); //在迭代器中使用List的方法,会出现并发修改异常
it.remove();//将java02的引用从集合中删除了
sop("obj="+obj);
}
*/
sop(al);
}
public static void method()
{
ArrayList al = new ArrayList();
//添加元素
al.add("java01");
al.add("java02");
al.add("java03");
sop("原集合是:"+al);
//在指定位置添加元素
al.add(1,"java09");
sop(al);
//删除指定位置的元素
al.remove(2);
//修改元素
al.set(1,"java007");
sop(al);
//通过下标获取元素
sop("get(1):"+al.get(1));
//获取所有元素
for(int x=0; x<al.size(); x++)
{
System.out.println("al("+x+")="+al.get(x));
}
Iterator it = al.iterator();
while(it.hasNext())
{
sop(it.next());
}
//通过indexOf获取元素的位置
sop("index="+al.indexOf("java02"));
//获取子列表
List sub = al.subList(1,3);
sop("sub="+sub);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
LinkedList:特有方法
addFist();
addLast();
getFist();
getLast();
获取元素,但不删除元素
removeFist();
removeLast();
获取元素,但元素被删除,如果集合中没有元素,会出现NoSuchElementException异常
在JDK1.6出现了替代方法
offerFirst();
offerLast();
peekFirst();
peekLast();
获取元素,但不删除元素,如果没有元素,返回null
pollFirst();
pollLast();
获取元素,但是元素被删除。如果集合中没有元素,会返回null
代码演示:
class LinkedListDemo
{
public static void main(String[] args)
{
LinkedList link = new LinkedList();
//依次在集合开始位置添加元素
link.addFirst("java01");
link.addFirst("java02");
link.addFirst("java03");
link.addFirst("java04");
sop(link);
sop(link.getFirst()); //获取集合中的第一个元素
sop(link.getLast()); //获取集合中的最后一个元素
sop("size="+link.size());
sop(link.removeFirst()); //获取集合第一个元素,并删除
sop(link);
while(!link.isEmpty())
{
sop(link.removeLast());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
使用LinkedList模拟一个线性的数据结构:
package LinkedListTest;
/*
使用LinkedList模拟一个堆栈或者队列数据结构
*/
import java.util.*;
class Queue
{
private LinkedList link;
Queue()
{
link = new LinkedList();
}
//添加元素
public void my_add(Object obj)
{
//在link开始位置添加元素
link.addFirst(obj);
}
//取出元素
public Object my_get()
{
return link.removeLast();
}
//判断链表是否为空
public boolean isNull()
{
return link.isEmpty();
}
}
class LinkedListTest
{
public static void main(String[] args)
{
Queue q = new Queue();
q.my_add("java01");
q.my_add("java02");
q.my_add("java03");
q.my_add("java04");
while(!q.isNull())
{
System.out.println(q.my_get());
}
}
}
CollectionDemo
1,add()方法的参数是Object类型,以便于接收任意对象
2,集合中存储的都是对象的引用(地址)
什么是迭代器呢?
其实就是集合取出元素的方式
把取出的方式定义在集合的内部
这样取出方式就可以直接访问集合内容的元素
而每一个容器的数据结构不同
所以取出的动作和细节也不一样但是都有共性的内容,判断和取出
可以将其共性抽取
那么这些内部类都符合一个规则
该规则是Iterator
如何获取集合的取出对象呢?
通过一个对外提供的方法 iterator();
代码演示:
package CollectionDemo;
import java.util.*;
class CollectionDemo
{
public static void main(String[] args)
{
method_2();
base_method();
method_get();
}
public static void method_get()
{
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
Iterator it = al.iterator(); //获取迭代器,用于取出集合中的元素
while(it.hasNext())
{
sop(it.next());
}
}
public static void method_2()
{
//创建一个容器,使用Collection接口的子类,ArrayList
ArrayList al1 = new ArrayList();
al1.add("java01");
al1.add("java02");
al1.add("java03");
al1.add("java04");
ArrayList al2 = new ArrayList();
al2.add("java01");
al2.add("java02");
al2.add("java05");
al2.add("java06");
//在al1中保留只包含和al2中相同的元素
al1.retainAll(al2);
//al1.removeAll(al2); //删除和al中元素相同的元素
sop("al1:"+al1);
sop("al2:"+al2);
}
public static void base_method()
{
//创建一个容器,使用Collection接口的子类,ArrayList
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
sop(al);
//删除元素
//al.remove("java02");
//al.clear(); //清空集合
//判断元素
sop("java03是否存在"+al.contains("java03"));
sop("集合是否为空? "+al.isEmpty());
//获取个数,集合长度
sop("size:"+al.size());
//打印改变后的集合
sop(al);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
ArrayList练习
取出ArrayList集合中的重复元素
将自定义对象作为元素存储到ArrayList集合中,并去除重复元素
思路:
1,对人描述,将数据封装进入对象
2,定义容器,将人存入
3,取出
List集合判断元素是否相同,依据元素的equals方法
代码演示:
package ArrayListTest;
import java.util.*;
class Person
{
//定义名字
private String name;
//定义年龄
private int age;
//构造函数初始化
Person(String name,int age)
{
this.name = name;
this.age = age;
}
//复写equals方法
public boolean equals(Object obj)
{
//如果传入的对象不是Person对象
if(!(obj instanceof Person))
return false;
Person p = (Person)obj;
//同姓名同年龄视为同一个元素
return this.name.equals(p.name) && this.age==p.age;
}
//获取姓名
public String getName()
{
return name;
}
//获取年龄
public int getAge()
{
return age;
}
}
class ArrayListTest
{
public static void main(String[] args)
{
method_2();
}
public static void method_2()
{
ArrayList al = new ArrayList();
//在ArrayList中存入Person对象
al.add(new Person("lisi01",30));
al.add(new Person("lisi02",32));
al.add(new Person("lisi03",33));
al.add(new Person("lisi04",35));
al.add(new Person("lisi05",38));
//定义一个迭代器
Iterator it = al.iterator();
while(it.hasNext()) //在循环中next()只能调用一次就要hasNext()判断一次
{
//Object obj = it.next();
//Person p = (Person)obj;
//Object中没有getName()和getAge()方法,必须向下转型
Person p = (Person)it.next();
sop(p.getName()+" "+p.getAge());
}
}
public static void method_1()
{
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java01");
al.add("java02");
al.add("java01");
al.add("java03");
sop(al);
al = singleElement(al);
sop(al);
}
public static ArrayList singleElement(ArrayList al)
{
//定义一个临时容器
ArrayList newAl = new ArrayList();
//定义一个迭代器
Iterator it = al.iterator();
while(it.hasNext())
{
Object obj = it.next();
//如果新容器中不包含obj,加obj添加到新容器
if(!newAl.contains(obj))
newAl.add(obj);
}
return newAl;
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
Vector
枚举就是Vector特有的取出方式
发现Enumeration和和Iterator很像
因为枚举的名称以及方法的名称都过长
所以被迭代器取代了
代码演示:
package VectorDemo;
import java.util.*;
class VectorDemo
{
public static void main(String[] args)
{
Vector v = new Vector();
v.add("java01");
v.add("java02");
v.add("java03");
v.add("java04");
//其实枚举和迭代是一样的
Enumeration en = v.elements();
while(en.hasMoreElements())
{
//取出下一个元素
System.out.println(en.nextElement());
}
}
}
Set
|--Set:元素是无序(存入和取出的顺序不一定一致),元素不可以重复
|--HashSet:底层的数据结构是哈希表
HashSet是如何保证元素唯一性的呢
如果元素的HashCode值相同,才会判断equals是否为true
如果元素的hashcode值不同,不会调用equals
|--TreeSet
Set 集合的功能和Collection是一样的
HashDemo代码演示:
package HashSetDemo;
import java.util.*;
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name = name;
this.age = age;
}
//覆盖hashCode方法
public int hashCode()
{
System.out.println(this.name+"....code");
return name.hashCode()+age()*39;
}
//覆盖equals方法
public boolean equals(Object obj)
{
if(!(obj instanceof Person))
return false;
//向下转型
Person p = (Person)obj;
System.out.println(this.name+"...equals.."+p.name);
return this.name.equals(p.name) && this.age == p.age;
}
}
class HashSetDemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
//创建一个HashSet集合对象
HashSet hs = new HashSet();
//在集合中添加元素
hs.add("java01");
hs.add("java02");
hs.add("java03");
hs.add("java04");
//Set集合只有一种取出方式,迭代器
Iterator it = hs.iterator();
while(it.hasNext())
{
sop(it.next());
}
}
}