------- android培训、java培训、期待与您交流！ ----------
一、String类
1、概述
（1）字符串是一个特殊的对象，例如：String s=“abc”，这里的abc其实是String类新建的一个对象。
（2）字符串一旦被初始化就不可以再改变了
注意：String s="abc"和String s1=new String（"abc"），其中s只有一个对象，s1中有两个对象（一个new，一个abc）。
在String类中的aquals（）方法比较的是字符串的内容（原因是它复写了Object类中的equals()方法）
2、String类中常用的方法
2.1、获取
（1）字符串的长度：int length（）；（和数组的长度是有区别的，数组的长度是数组的一个属性，而字符串的则是它的一个方法）
（2）根据index（位置）获取此位置上的字符：char charAt（int index）；
（3）根据根据字符获取该字符在字符串中的位置
int indexOf（int ch）返回值是ch（ASCII）在字符串中第一次出现的位置。
int indexOf（int ch，int fromIndex）从指定位置开始，返回值是ch（ASCII）在字符串中第一次出现的位置。
int indexOf（String str）；返回值是str在字符串中第一次出现的位置。
int indexOf（String str，int fromIndex）从指定位置开始，返回值是str在字符串中第一次出现的位置。
int lastIndexOf（int ch）反向索引。
2.2、判断
（1）字符传中是否包含某一个字符子串：boolean contains（str）；
注意：indexOf（str）也可以判断是否包含此子串，如果字符串中没有就返回-1；
（2）判断字符中是否有内容：boolean isEmply（）；
（3）字符串是否以某一字符开头或结尾：boolean startsWhit（str），endsWhit（Str）；
（4）判断字符串中内容是否相同：boolean equals（str）；
（5）判断内容是否相同（忽略大小写）：boolean equalsIgnoreCase（）；
2.3、转换
（1）将字符数组转换成字符串：
构造函数：String（char[]）
String（char[],offset,count）从offset位置起,共count个字符转化.
静态方法：static String copyValueOf（char[]）
static String copyValueOf（char[],int offset,int count）
（2）将字符串转化成字符数组：char[] toCharArray（）；
（3）将字节数组转化成字符串：同（1）
（4）将字符串转化成字节数组：byte[] getBytes();
（5）将基本数据类型转化成字符串
static String valueOf（int）
static String valueOf（double）
注意：字符串和字节数组在转换过程中，可以使用编码表。
2.4、替换
String replace（oldchar，newchar）；
2.5、切割
String[] split(regex)
2.6、获取字符串中一部分
String substring（begin）
String substring（begin，end）
2.7、转换，去除空格，比较
（1）将字符串进行大小写转换
String toUpperCase（）；
String toLowerCase（）；
（2）去除空格
String trim（）；
（3）对两个字符串进行自然顺序的比较
int compareTo（string）
3、StringBuffer是一个字符串缓冲区,是一个容器.(c 、create；u、update；r、read；d、delate）
特点：（1）长度可变化； 例：StringBuffered sb=new StringBuffer（）；
（2）可以直接操作多种数据类型； sb.append(“abc”).append(true).append(2);
（3）最终可以通过toString方法变成字符串。 sb.toString();
3.1、存储
（1）append（）；将指定的数据（任意数据类型）作为参数添加到已有数据的结尾处。
（2）insert（index；数据）；将数据添加到已有数据的特殊位置。
3.2、删除
（1）delete（start，end）包含头不包含尾
（2）deleteCharAt（index）删除指定位置的数据
3.3、获取
（1）char charAt（index）
（2）int indexOf（String str）
（3）int lastIndexOf（String str）
（4）int length（）
3.4、修改
（1）SringBuffer replace（start，end，String Str(要替换的字符串)）
（2）void setCharAt（index，str）
3.5、反转
Stringbuffer reverse（）
3.6、将缓冲区中的指定数据存到指定数组中
void getChars(int srcBegin,int srcEnd,char[]dst,int dstBegin);src(圆),dst(目的)
4、JDK1.5以后出现了StringBuilder
这俩的区别：StringBuffer 是线程同步的，StringBuilder是线程不同步的。
5、基本数据类型对象包装类
（1）基本数据类型对应的类
byte--Byte short--Short inter--Integer long--Long boolean--Boolean float--Float double--Double char--Character
（2）最常见的作用：就是用于基本数据类型和字符串数据之间的转换。
基本数据类型变成字符串：基本数据类型值+“”；基本数据类型.toString（基本数据类型值）；例:Integer.toString(1);
字符串转换成基本数据类型：Integer.parseInt（String）；
（3）JDK1.5以后出现的新特性
Integer x=new Integer（4）新特性以后可以写成：Integer x=4 （这里存在一个自动装箱的动作，就是4就相当于new Integer（4））；
x=x+4：这个运算里面存在一个自动拆箱跟自动装箱的动作，先将x这个对象拆成int型数据（x.intValue（）），运算以后再进行装箱。
数值在byte范围内的数据，在新特性出来以后，如果数值存在不会再开辟新空间
例：Integer x=128； Integer x=127；
Integer y=128； x==y false； Integer x=127； x==y true；
二、集合类
1、集合类的概述
（1）为了方便对多个对象的操作，就对对象进行了存储（集合）。
（2）和数组的区别：数组只可以存储同一类型的对象，并且数组长度是固定的，数组可以操作基本类型数据。集合可以存储不同类型的对象，长度是可变化的，集合只用于存储对象。
（3）集合框架
（4）出现这么多容器的原因：容器对数据的存储方式不同，这种存储方式称之为数据结构。
2、Collection中的方法
ArrayList：底层数据结构是数组结构，特点：查询速度快，但删除速度慢，线程不同步
LinkedList：底层数据结构是链表数据结构，特点：增删速度快，查询慢，线程不同步
2.1、添加
add（Object obj）
注意：add方法的参数类型是Object（可以装任意类型的对象），集合中存储的都是对象的地址。
2.2、长度：集合.size（）；
2.3、删除元素：集合.remove（元素）；（注意：这里的判断调用的是元素的equals方法）
集合.clear（）表示清空集合。
2.4、判断：集合.contain（元素）：判断元素是否存在。（注意：这里的判断调用的是元素的equals方法）
集合.isEmpty（）：集合是否为空。
2.5、取交集：集合1.retainAll（集合2）。
2.6、获取元素（迭代器）
（1）Iterator it=集合.iterator（）获取迭代器
（2）it.hasNext（）判断容器中是否还有元素
（3）it.next（）取出一个元素。
（4）it.remove（）删除一个元素。
注意：Iterator it=al.iterator（） 和 for（Iterator it=al.iterator（）； it.hasNext（）；）
while（it.hasNext（）） it.next（）；
it.next（）；
区别在于：第一个取完元素，迭代器还存在于内存中，而第二个是取完就会消失。
3、List中的特有方法
3.1、List和Set的不同之处
List：元素是有序的，可以重复。（原因是该集合有角标）
Set：该集合的元素是无序的，不可以重复。
3.2、在指定位置添加元素：add（index，元素）
添加某一集合中所有元素：add（index，Collection）
3.3、删除特定位置的元素：remove（index）
3.4、修改特定位置的元素：set（index，元素）
3.5、获得特定位置的元素：get（index）
获取子列表：subList（fromIndex，toIndex）
注意：集合中获取元素的方式有两种：一种是迭代器，一种是集合特有的获取方式，两种方式同时运行时，会出现安全隐患。
4、LinkedList特有方法
4.1、将元素添加到集合的首位：addFirst（）；
4.2、将元素添加到集合的尾位：addLast（）；
4.3、获取元素：getFirst（），getLast（）只取不删
4.4、删除元素：removeFirst（），removeLast（）可以取，取了就在容器中删除。
注意：若是集合中没有元素就会报错：NoSuchElementException。
在JDK1.6以后提供了offer代替了add；peek代替了get；poll代替了remove，若集合为空则返回null。
5、练习1：模拟堆栈或队列数据结构（堆栈：先进后出；队列：先进先出）
import java.util.*;
class DuiLie
{
private LinkedList link;
DuiLie()
{
link=new LinkedList();
}
/*
添加元素的方法myAdd:每次添加的元素都放在第一位,
这里用了LickedList中的Addirst()方法实现的
*/
public void myAdd(Object obj)
{
link.addFirst(obj);
}
/*
获取元素的方法myGet:每次获取的元素都放在最后一位,
这里用了LickedList中的removeLaet()方法实现的
*/
public Object myGet()
{
return link.removeLast();
}
/*
判断集合中还有元素的方法isNull(),
这里用了LickedList中的isEmpty()方法实现的
*/
public boolean isNull()
{
return link.isEmpty();
}
}
class DuiLieTest
{
public static void main(String[] args)
{
DuiLie dl=new DuiLie();
dl.myAdd("chy01");
dl.myAdd("chy02");
dl.myAdd("chy03");
dl.myAdd("chy04");
while(!dl.isNull())
{
sop(dl.myGet());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
总结:(1)ArrayList 中获取元素有两种方法:一种和数组一样,通过控制长度来获取元素(size控制长度,get获取元素);另一种是迭代器.
(2)LinkList获取元素的方法:除了上两种方法,还可以通过控制集合是否为空,和删除元素来取(isEmpty来控制是否为空,removefirst来取).
练习2:删除集合中相同的元素(对象)
import java.util.*;
class Person
{
private int age;
private String name;
Person(String name,int age)
{
this.name=name;
this.age=age;
}
/*重写父类中的equals方法,建立自己独特的比较方式*/
public boolean equals(Object obj)//相当于Object obj=new Person();
{
//判断比较类型是否是相同类型.
if(!(obj instanceof Person))
return false;//这里最好返回异常,让程序停止.
Person p=(Person)obj;//向下转型,父类不能调用子类方法
return this.name.equals(p.name) && this.age==p.age;
}
public int getAge()
{
return age;
}
public String getName()
{
return name;
}
}
class ListTest
{
public static void main(String[] args)
{
ArrayList al=new ArrayList();
al.add(new Person("chy",2));
al.add(new Person("chy",122));
al.add(new Person("chy",123));
al.add(new Person("chy",125));
al.add(new Person("chy",2));
sop(al);
al=singlePerson(al);
//对新集合中的元素进行遍历
Iterator it=al.iterator();
while(it.hasNext())
{
Person p=(Person)it.next();
sop(p.getName()+"..........."+p.getAge());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
//保证元素唯一的方法
public static ArrayList singlePerson(ArrayList al)
{
//建立一个新的集合
ArrayList newAl=new ArrayList();
//遍历老集合中的元素
Iterator it=al.iterator();
while(it.hasNext())
{
Object obj=it.next();
if(!newAl.contains(obj))
newAl.add(obj);
}
return newAl;
}
}
6、Set集合
6.1、HashSet ：底层数据结构是哈希表，特点：先看哈希值，在比较对象内容。
6.2、HashSet是怎样保持元素的唯一性的：它是通过元素的两个方法（hashCode（）和equals（））来完成的，如果hashCode值相同，才会判断equals 是否相同。反之不会判断equals，
6.3、判断元素是否存在或是删除元素依赖的方法也是hashCode和equals。
6.4、hashCode()方法获取的不同的对象对应的哈希值,可以通过覆盖这个方法来自定义哈希值.(就是在方法体中返回一个int类型的值)
注意：如果不同对象的哈希值相同，内容不同，他们会在同一个地址上顺延。
6.5、TreeSet （解决了Set集合不可以给元素排序的问题）
（1）底层数据结构是二叉树，特点：二叉数数据结构可以减少集合中比较次数，以此来提高效率。
（2）TreeSet保证元素唯一性的依据：用compareto这个方法来验证来验证两个元素是否相同，返回值为零表示两数相同，不存，返回正数，表示新来的元素大于已有的元素，返回负数，表示小于已有的元素。
（3）TreeSet有两种排序方式：
第一种：让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法，这种排序的结果是元素的自然顺序。
第二种：出现第二种方式的原因是：元素自身不具备比较性或者具备的比较性不是所需求的，这是可以让集合自身具备比较性。
具体实现方式是：定义一个比较器（让比较器去实现Comparator接口，覆盖它其中的caopare（）方法），在集合初始化是，将比较器传给集合。
7、泛型
（1）泛型是JDK1.5以后出现的新特性，用于解决安全问题（集合中的），是一个类类型安全机制。
（2）好处：将运行时期出现的问题（类型转换问题）转移到编译时期，方便于程序员解决问题，让运行时期问题减少。
避免了强制转换的麻烦。
例子：建立一个集合，里面存了一对字符串对象，再存一个整数对象，用迭代器取出时想获取字符串以及其长度，就要对这些对象进行强转，这些动作在编译时是不会出错的，但是在运行时就会出现ClassCastException异常（Integer不能转化成String）
（3）泛型的格式：通过<>来定义要操作的数据类型。
（4）什么时候来定义泛型：大多数情况是在集合中，使用集合时，将集合中要存储的的数据类型作为参数传递到<>中即可。
（5）泛型类：就是在类后面加上一个<T>,T表示不确定引用数据类型.(例子:看15天08)
（6）泛型方法：将泛型定义在返回值的前面，修饰符的后面。
（7）静态泛型方法：静态方法不可以访问泛型类上定义的泛型，若是静态方法的类型和类不同，可以将泛型定义在静态方法上。
8、泛型的限定
（1）<? extends E>可以在泛型中接受E类或E的子类，这是上限。?指的是通配符或是占位符
（2）<? super E>可以在泛型中接受E类或E的父类，这是下限。
总结:学完这两种集合以后,以后再定义对象,除了简单的获取意外,还必须重写equals和hashCode方法(目的是为了保证HashSet的唯一性),实现Comparable接口并重写compareTo方法(目的是为了让元素自身具有比较性)
三、Map集合
1、Map集合的基本特点:和Collection集合不同,Map中存储的是键值对(Map<key,value>).
2、（1）Hashtable ：底层数据结构是哈希表，null不可以作键也不可以作值，线程是同步的，（JDK1.0）
（2）HashMap ：底层数据结构是哈希表，null可以作键也可以作值，线程是不同步的，（JDK1.2）
（3）TreeMap：底层是二叉树，线程不同步，可用于对Map集合中的键进行排序。
3、Map集合保证唯一的依据：在Map中的键是不能重复，的因此可以将键放入Set集合中，根据Set集合的唯一性来保证Map的唯一性
4、Map的一些方法
（1）添加
Set keyset=map.keySet();//将Map中的键传入Set集合中
Iterator it=keyset.iterator();
while(it.hasNext())
{
Object key=it.next();//获取键
Object Value=map.get(key);//获取值
}（2）entrySet():将键和值的映射关系存到Set集合中,再用Set的迭代器将值取出
Set entryset=map.entryset();//将Map中的键值间的映射传入Set集合中
Iterator it=entryset.iterator();
while(it.hasNext())
{
Map.Entry me=(Map.Entry)it.next()//将键值间的映射关系存到Map.Entry中
Object key=me.getKey();//通过Entry中getKey方法获取键
Object value=me.getValue();//通过Entry中getValue方法获取值
}6、Collections：这个类不需要创建对象，它内部的方法都是静态方法，它就是集合的一个工具类
将集合中的元素存储到数组中，其他位置为默认值null。
for(String s:al)//Arraylist<String> al=new Arraylist<String> ()
{
s="kk";
sop(s);//打印出来的全是"kk"
}
sop(s);//打印出来的是原集合的内容
620
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
