------- android培训、java培训、期待与您交流！ ----------
1，字符串是一个特殊的对象；
2，字符串一旦初始化就不可以被改变；
3，String str="abc";与String str=new String("abc");的区别：
str代表一个对象，str代表两个对象。
String类复写了Object类中的equals方法，该方法用于判断字符串是否相同。
String类常见操作及方法：
1，获取
1.1 字符串长度：int length（）；
1.2 获取指定位置上的字符：char charAt（int index）；
1.3 获取字符串的位置： int indexOf（int ch）；返回的是ch在字符串中第一次出现的位置，
如果没有找到，返回-1。
indexOf（int ch，int fromIndex）：从fromIndex指定位置开始获取位置。
indexOf（String str）：返回str的位置。
indexOf（String str，int fromIndex）
lastIndexOf（int ch）：反向索引。
2，判断
2.1 字符串中是否包含某一子串：boolean contains（str）；
特殊之处：indexOf（str）可以索引str第一次出现的位置，如果返回-1，表示该str不在字符串中，
所以也可以用于判断是否包含。
2.2 字符串是否有内容：boolean isEmpty
2.3 字符串是否与指定内容开头：boolean startsWith（）；
2.4 字符串是否与指定内容结尾：boolean endsWith（）；
2.5 判断字符串内容是否相同（复写了Object类中equals方法）：boolean equals（str）；
2.6 判断字符串内容是否相同，并忽略大小写：boolean equalsIgnoreCase（）；
3,转换
3.1 将字符数组转成字符串：
构造函数方法：String（char[]）
String(char[],offset,count);将字符数组中的一部分转成字符串。
静态方法：static String copyValueOf(char[]);
static String copyValueOf(char[],offset,count);
3.2 将字符串转成字符数组：char[] toArray();
3.3 将字节数组转成字符串: String(byte[])
3.4 将字符串转成字节数组: byte[] getByte();
3.5 将基本数据类型转换成字符串:static String valueOf(int/double);
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 compareTo(string);
练习：
/*
需求：获取一个字符串在另一个字符串中出现的次数
思路：1、定义一计数器
2、获得字符串第一次在另个字符中出现的位置
3、从第一次出现的位置后剩余的字符串中继续获取字符串出现的次数，每出现一次，计数器就加一次
3、当获取不到时候，计数停止
*/
class HuoQu
{
public static int method(String str,String key)
{
int count=0;//定义技术器
int index=0;//定义获取角标变量
while((index=str.indexOf(key,index))!=-1)//判断剩下的子串中是否还有key
{
System.out.println("index="+index);
index=index+key.length();//从找到的子串位置后一位开始获取
count++;
}
return count;
}
public static void main(String[] args)
{
String str="ssmelonssfightingssinssjuness";
String key="ss";
System.out.println("count="+method(str,key));
}
}
StringBuffer可以对字符串内容进行增删。
StringBuffer是一个容器，很多方法与String相同。
StringBuffer是可变长度的，可以操作多个数据类型。
最终会通过toString方法变成字符串。
1，储存
StringBuffer append()：将指定数据添加到已有数据的结尾处。
StringBuffer insert(index 数据)：将数据添加到指定index位置。
2，删除
StringBuffer delete(start,end);删除缓冲区中的数据，包含start，不包含end。
StringBuffer deleteCharAT(index):删除指定位置字符。
3，获取
char charAt(int index); int lastIndexOf(String str);
int indexOf(String str);int length();
String substring(int start,int end);
4，修改
StringBuffer replace(start,end,string);
void setCharAt(index,char ch);
5，反转
StringBuffer reverse();
6，将缓冲区指定数据存储到指定字符串中
void getChars(int srcBegin,int srcEnd,char[] chs,int dstBegin);
JDK1.5版本之后出现了StringBuilder。
StringBuffer是线程同步，而StringBuilder是线程不同步。开发建议使用StringBuilder。
byte Byte
short Short
int Integer
long Long
boolean Boolean
float Float
double Double
char Character
基本数据类型对象封装类最常见的作用：用于基本数据类型和字符串类型之间作转换。
基本数据类型转成字符串
基本数据类型+""；
基本数据类型.toString(基本数据类型值)；
如：Integer.toString(84);
字符串转基本数据类型：
xxx a = Xxx.parseXxx(String);
如：int a=Integer.parseInt("123");
非静态方法：如：Integer i=new Integer("123");
i.intValue();
十进制转成其他进制
toBinaryString();
toHexString();
toOctalString();
其他进制转成十进制
parseInt(string,radix);
就对对象进行存储，集合就是存储对象最常用的一种方式。
集合与数组的区别：
数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。
集合类的特点：
1，集合只用于存储对象，
2, 集合长度是可变的，
3，集合可以存储不同类型的对象。
Collection接口：Collection是集合框架中的常用接口。其下有两个子接口：List（列表），Set（集）。
Collection接口中的常见操作
1、添加元素
add(Objectobj); //add方法的参数类型是Object。以便于接收任意类型对象。
2、删除元素
remove();
removeAll();//调用者只保留另一集合中没有的元素。
clear();//清空集合
3、判断元素
contains(Objectobj);//判断是否存在obj这个元素
isEmpty();//是否为空
4、获取个数，集合长度
size();
5、取交集
retainAll(另一集合);//调用者只保留两集合的共性元素。
注：集合中存储的都是对象的引用（地址）。
迭代器
常见操作：
hasNext();//有下一个元素，返回真
next();//取出下一个元素
remove();//移除
注：在迭代时循环中next调用一次，就要hasNext判断一次。
如：
ArrayList a=newArrayList();//创建一个集合
Iteratorit=a.iterator();//获取一个迭代器，用于取出集合中的元素。
//第一种打印方式：
for(Iterator iter = a.iterator();iter.hasNext();)
{
System.out.println(iter.next());
}
// 第二种打印方式：
Iteratoriter = a.iterator();
while(iter.hasNext())
{
System.out.println(iter.next());
}List
List：元素是有序的，元素可以重复。因为该集合体系有索引。
|--ArrayList：底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。
|--Vector：底层是数组数据结构。线程同步。被ArrayList替代了。
List的特有方法： 凡是可以操作角标的方法都是该体系特有的方法。
1、增
booleanadd(index,element);//指定位置添加元素
BooleanaddAll(index,Collection);//在指定位置增加给定集合中的所有元素，
若省略位置参数，则在当前集合的后面依次添加元素
2、删
Booleanremove(index);//删除指定位置的元素
3、改
set(index,element);//修改指定位置的元素。
4、查
get(index);//通过角标获取元素
subList(from,to);//获取部分对象元素
5、其他
listIterator();//List特有的迭代器
indexOf(obj);//获取元素第一次出现的位置，如果没有则返回-1
注：List集合判断元素是否相同，移除等操作，依据的是元素的equals方法。
ListIterator：是List集合特有的迭代器，是Iterator的子接口。该接口出现的原因是在迭代时，不可以通过集合对象的方法操作
元素，因为会发生ConcurrentModificationException(并发修改异常)，又因为Iterator方法是有限的，所以需要其
子接口ListIterator。
ListIterator特有的方法
add(obj);//增加
set(obj);//修改为obj
hasPrevious();//判断前面有没有元素
previous();//取前一个元素
LinkedList
特有方法：
1、增
addFirst();
addLast();
2、获取
//获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException
getFirst();
getLast();
3、删
//获取元素，并删除元素。如果集合中没有元素，会出现NoSuchElementException
removeFirst();
removeLast();
在JDK1.6以后，出现了替代方法。
1、增
offFirst();
offLast();
2、获取
//获取元素，但是不删除。如果集合中没有元素，会返回null。
peekFirst();
peekLast();
3、删
//获取元素，并删除元素。如果集合中没有元素，会返回null。
pollFirst();
pollLast();
LinkedList练习：
import java.util.*;
class MyDuiLie//队列：先进先出 First in First out FIFO
{
private LinkedList li;
MyDuiLie()
{
li=new LinkedList();
}
public void mySet(Object obj)
{
li.addFirst(obj);
}
public Object myGet()
{
return li.removeLast();
}
public boolean myNull()
{
return li.isEmpty();
}
}
class MyDuZhan//堆栈：先进后出
{
private LinkedList lt;
MyDuZhan()
{
lt=new LinkedList();
}
public void mySetxx(Object obj)
{
lt.addFirst(obj);
}
public Object myGetxx()
{
return lt.removeFirst();
}
public boolean myNullxx()
{
return lt.isEmpty();
}
}
class LinkedListTest
{
public static void main(String[] args)
{
MyDuiLie dl=new MyDuiLie();
dl.mySet("DuiLie001");
dl.mySet("DuiLie002");
dl.mySet("DuiLie003");
dl.mySet("DuiLie004");
dl.mySet("DuiLie005");
dl.mySet("DuiLie006");
while(!dl.myNull())//调用myNull方法，判断集合是否为空
{
System.out.println("队列"+dl.myGet());
}
MyDuZhan dz=new MyDuZhan();
dz.mySetxx("DuZhan001");
dz.mySetxx("DuZhan002");
dz.mySetxx("DuZhan003");
dz.mySetxx("DuZhan004");
dz.mySetxx("DuZhan005");
dz.mySetxx("DuZhan006");
while(!dz.myNullxx())
{
System.out.println("堆栈"+dz.myGetxx());
}
}
}Set：元素是无序（存入和取出的顺序不一定一致），元素不可以重复。
|--HashSet：底层数据结构是哈希表。线程不同步。 保证元素唯一性的原理：判断元素的hashCode值是否相同。
如果相同，还会继续判断元素的equals方法，是否为true。
|--TreeSet：可以对Set集合中的元素进行排序。默认按照字母的自然排序。底层数据结构是二叉树。
保证元素唯一性的依据：compareTo方法return 0。
Set集合的功能和Collection是一致的。
HashSet
HashSet：线程不安全，存取速度快。
可以通过元素的两个方法，hashCode和equals来完成保证元素唯一性。
如果元素的HashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不会调用equals。
注意：HashSet对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。
TreeSet
1，特点
a，底层的数据结构为二叉树结构（红黑树结构）
b，可对Set集合中的元素进行排序，是因为：TreeSet类实现了Comparable接口，
该接口强制让增加到集合中的对象进行了比较，需要复写compareTo方法，才能
让对象按指定需求（如人的年龄大小比较等）进行排序，并加入集合。
java中的很多类都具备比较性，其实就是实现了Comparable接口。
注意：排序时，当主要条件相同时，按次要条件排序。
c、保证数据的唯一性的依据：通过compareTo方法的返回值，是正整数、负整数或零，则两个对象较大、较小或相同。相等时则不会存入。
TreeSet排序图解
TreeSet排序的两种方式
1）第一种排序方式：自然排序
让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。
这种方式也被称为元素的自然顺序，或者叫做默认顺序。
2）第二种方式：比较器
当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。
在集合初始化时，就有了比较方式。定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
比较器构造方式：定义一个类，实现Comparator接口，覆盖compare方法。
当两种排序都存在时，以比较器为主。
TreeSet练习：
/*
需求：按照字符串长度排序
*/
import java.util.*;
class TreeSetTest
{
public static void main(String[] args)
{
TreeSet ts =new TreeSet(new StrLenCom());
ts.sdd("dfrs");
ts.sdd("adg");
ts.sdd("aaa");
ts.sdd("gvbyg");
ts.sdd("mn");
ts.sdd("y");
ts.sdd("goodluck");
Iterator it=ts.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
//自定义比较器，按自己的要求进行排序
class StrLenCom implements Comparator
{
public int compare(Object o1.Object o2)//覆盖compare方法
{
String s1=(String)o1;
String s2=(String)o2;
int num=new Integer(s1.length()).compareTo(new Integer(s2.length()));
if(num==0)
return s1.compareTo(s2);
return num;
}
}
420
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
