黑马程序员技术交流社区

标题: 给大家分享一点StringBuffer和StringBuilder的总结 [打印本页]

作者: 山西_李帅 时间: 2013-4-14 22:51
标题: 给大家分享一点StringBuffer和StringBuilder的总结
本帖最后由山西_李帅于 2013-4-14 22:52 编辑

1.StringBuffer的方法总结
      构造方法
            1,StringBuffer();
            2,StringBuffer(int len);
            3,StringBuffer(String s);
      成员方法
            1,append(参数 c);       c可以为基本类型，char[]，Object，String或StringBuffer
            返回值是StringBuffer
            2,toString();  转换成String类型
            3，insert(index, char c);
            4,delete(int start, int end);
               deleteCharAt(int index);
            5,reverse(); 反转
            6,setCharAt(int index, char c);       使用c替换index位置上的字符

2.包装类的作用
      1，它可以将基本类型包装秤对象
      2，它可以在基本类型与String类型之间转换
      3，它可以在String和引用类型之间转换

3.StringBuffer与StringBuilder的区别
      StringBuffer是线程比较安全，同步，效率低。
      StringBuilder是线程不安全，异步，效率高。

4.Integer类中的方法总结
      intValue
      声明:public int intValue();
      作用:就是得到Integer对象中的包装的int属性值

      toString方法
      声明 public static String toString(int value);
      作用将一个int类型的值转换成String

      parseInt方法(重点)
      声明 public static int parseInt(String s)
      作用将一个String类型的数据转换成int

      toBinaryString
      声明: public static String toBinaryString(int i)
      作用: 将一个数字转换成二进制

      toOctalString
      声明: public static String toOctalString(int i)
      作用: 将一个数字转换成八进制

      toHexString
      声明: public static String toHexString(int i)
      作用: 将一个数字转换成十六进制

下面就是集合了。这几天会一直更新，一起加油
5.Collection体系结构图
|---Collection
      |---List :有顺序的可重复
                     ｜----ArrayList
                     |----LinkedList
                     |----Vector
      |---Set  :无顺序不可重复
                     |-----HashSet
                     |-----TreeSet

6.Collection接口中的方法总结
      1.add 向集合中添加元素
      声明:public boolean add(Object obj)
      作用:向集合添加元素obj
      参数:要添加的元素
      返回值:代表是不否添加成功.

      2.clear 清空集合中的元素
      声明:public void clear();
      作用:清空集合中所有元素

      3.contains 判断集合中是否包含指定元素
      声明:public boolean contains(Object obj)
      作用:判断集合中是否包含指定元素，如果包含返回true，不包含返回false;
      注意：所谓的包含是指obj与集合中的元素做equals返回true.

      4.size
      声明:public int size();
      作用:返回集合中元素的个数

      5.isEmpty
      声明:public boolean isEmpty();
      作用:判断集合中是否包含元素，如果没有任何元素返回true,有元素返回false

      6.remove
      声明:public boolean remove(Object obj)
      作用:删除集合中的指定元素obj，如果删除成功返回true,否则返回false
      注意:一次只能删除一个.

7.List与Set的区别
List :有顺序的可重复
Set  :无顺序不可重复

作者: Alan 时间: 2013-4-15 01:10
抢个沙发十个字不到

作者: 山西_李帅 时间: 2013-4-15 20:29
继续更新喽。这次给大家都附带上每一个方法的例子。

作者: 山西_李帅 时间: 2013-4-15 20:29
List集合
List集合的特点:有顺序可重复
List是继承自Collection，Collection中的方法在List中都是存在。
List集合中的特性方法:
因为List集合是有顺序的，我们可以对其元素进行精确控制，通过索引.
1.add方法
声明:public void add(int index,Object obj);
作用:在指定index索引位置添加元素
//add(int index,Object obj)
public static void method1(){
List list=new ArrayList();
list.add("hello");
list.add("world");
list.add(1,"ok"); //这个方法的作用是将ok添加到1这个索引的位置
System.out.println(list);
}
2.get方法(***)
声明:public Object get(int index);
作用:根据索引index得到对应位置上的元素
//Object get(int index)
public static void method2(){
List list=new ArrayList();
list.add("hello");
list.add("world");
list.add("ok");
//String obj=(String)list.get(1);
//System.out.println(obj);
for(int i=0;i<list.size();i++){
String s=(String)list.get(i);
System.out.println(s);
}
}
3.remove方法
声明:public Object remove(int index);
作用:将指定index索引位置上的元素删除，返回值就是删除的元素.
//remove
public static void method3(){
List list=new ArrayList();
list.add("hello");
list.add("world");
list.add("ok");
Object obj=list.remove(0);
System.out.println(list);
System.out.println("obj="+obj);
}
4.set方法
声明:public Object set(int index,Object obj)
作用:使用obj将index位置上的元素替换，返回值是被替换的元素.
//set
public static void method4(){
List list=new ArrayList();
list.add("hello");
list.add("world");
list.add("ok");
Object obj=list.set(1,"小张");
System.out.println(list);
System.out.println("obj="+obj);
}
List集合的遍历方式
1.通用方式 Iterator（适用于所有的Collection集合）
通过从Collection继承的iterator方法
//1.使用迭代器
public static void method1(){
List list=new ArrayList();
list.add("张三丰");
list.add("张无忌");
list.add("李莫愁");
list.add("吴莫愁");
for(Iterator it=list.iterator();it.hasNext();){
String s=(String)it.next();
System.out.println(s);
}
}
2.使用get（只适用于List集合）
因为List集合是有顺序的，我们可以通过索引对其位置上进行控制
//2.使用索引进行操作
public static void method2(){
List list=new ArrayList();
list.add("张三丰");
list.add("张无忌");
list.add("李莫愁");
list.add("吴莫愁");
for(int i=0;i<list.size();i++){
String s=(String)list.get(i);
System.out.println(s);
}
}
3.使用List集合的特有的迭代器械  ListIterator(只适用于List集合)
ListIterator是继承自Iterator，也就是在Iterator中声明的hasNext,next,remove方法它也有。
但是它还提供了特有的方法 add    set
//3.使用ListIterator
public static void method3(){
List list=new ArrayList();
list.add("张三丰");
list.add("张无忌");
list.add("李莫愁");
list.add("吴莫愁");
//在迭代的过程中对元素进行操作
ListIterator lt=list.listIterator();
while(lt.hasNext()){
String s=(String)lt.next();
if("张三丰".equals(s)){
//lt.add("梅超疯");  //在迭代过程中对元素进行操作
lt.set("梅超疯");
}
//System.out.println(s);
}
System.out.println(list);
/*
while(lt.hasPrevious()){
String s=(String)lt.previous();
System.out.println(s);
}*/
}
ListIterator比Iterator功能增强
1.Iterator只能从上到下遍历，而ListIterator可以双向遍历
2.Iterator在迭代过程中不能修改,而ListIterator可以add ,set
ArrayList
我们主要研究，ArrayList的实现方式
ArrayList它的实现是使用可变数组
ArrayList类的特点:
1.它的底层实现是使用数组实现。
2.每一次数组会扩充50%
（trimToSize() 将此 ArrayList 实例的容量调整为列表的当前大小。）
3.它是线程不安全。在单线程中使用。
class MyList
{
private Object[] obj;
private int size=0;
public MyList(){
this(10);
}
public MyList(int len){
obj=new Object[len];
}
public void add(Object o){
obj[size]=o;
//为了实现可以一直向MyList中不断的添加元素.
change();
size++;
}
private void change(){
Object[] old=obj;
obj=new Object[old.length*3/2]; //在原来数组基础上扩大50%
/*
for(int i=0;i<old.length;i++){
obj[i]=old[i];
}*/
}
public String toString(){
StringBuilder builder=new StringBuilder();
builder.append("[");
for(int i=0;i<size;i++){
builder.append(obj[i]).append(",");
}
builder.deleteCharAt(builder.length()-1);
builder.append("]");
return builder.toString();
}
}
LinkedList
特点：
LinkedList的底层实现:双向链表
LinkedList特殊的方法:它可以很方便的操作集合的头尾元素.
它对外提供了 get/remove/add
关于ArrayList与LinkedList集合区别?
ArrayList底层是使用数组实现，在内存中是连续的空间，那么他在做查找时会方法，
但是在做删除/修改时效率比较低.
LinkedList它的底层实现是链表实现，它在做查找时效率比较低。转为每一个元素
头存储的是上一个元素的地址，尾存储的是下一个元素的地址。
但是，它在做删除与修改时效率高。
LinkedList集合的特性方法
1.addFirst/addLast
声明:public void addFirst(Object obj);
作用:将obj元素添加到集合的首位置
声明:public void addLast(Object obj)
作用:将obj元素添加到集合的尾位置
//在jdk1.6后提供两个替代的方法
offerFirst
offerLast
它与我们addFirst与addLast区别在于它有返回值.
//addFirst  addLast
public static void method1(){
LinkedList list=new LinkedList();
list.add("a");
list.add("b");
list.addFirst("abc");
list.addFirst("first");
list.add("c");
list.addLast("d");
list.add("e");
System.out.println(list);
}
2.getFirst/getLast
声明:public Object getFirst();
作用:得到集合中的首元素
声明:public Object getLast();
作用:得到集合的尾元素
在jdk1.6后提供替代方法
peekFirst
peekLast
它们与getFirst/getLast区别,它们在集合为空时，返回的是null,而不会产生异常.
//getFirst  getLast
public static void method2(){

LinkedList list=new LinkedList();
//list.add("a");
//list.add("b");
//list.add("c");
//list.add("d");
//list.add("e");

System.out.println(list.getFirst());  //list.get(0);
System.out.println(list.getLast());  //list.get(list.size()-1);
}
3.removeFirst/removeLast
声明:public Object removeFirst();
作用:删除集合中的首元素，返回的就是删除的这个元素
声明:public Object removeLast()
作用:删除集合中的最后一个元素，返回的是删除的这个元素.
jdk1.6后替换的方法
pollFirst
pollLast
它们区别在于pllFirst/pollLast列表为空时不会产生异常，而是返回null;
注意:对于getFirst/getLast removeFirst/removeLast时，如果集合为空
      会产生异常.
//removeFirst  removeLast
public static void method3(){
LinkedList list=new LinkedList();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
list.clear();
System.out.println(list.removeFirst());
System.out.println(list.removeLast());
System.out.println(list);
}
Vector(了解)
Vector是早期应用集合时所使用的一个类.
ArrayList是Vector的替代类.
ArrayList是数组实现，它是每次增加50%,线程不安全.
Vector 是数组实现  它每次拉回100%,线程安全的。
关于使用Enumeration遍历Vector
//1.得到Enumeration对象
Enumeration enu=v.elements();
//2.判断是否有元素可以进行迭代
while(enu.hasMoreElements()){
//3.得到元素
Object obj=enu.nextElement();
System.out.println(obj);
}
List集合的总结
List 有顺序可重复.
|----ArrayList
它的底层实现是使用数组，每次增长50%,在做查询操作时效率高。是线程不安全。
|----LinkedList
它的底层实现是使用链表，它在做修改与删除时效率高。线程不安全。
Linkedlist对于首尾元素操作比较方便.
|----Vector
它的底层实现是数组，每次增长100%,效率低下，线程安全。
对于List集合的遍历方式
1.Iterator
2.get+索引
3.listIterator
Set集合
Set集合:无顺序不可重复
|----HashSet
它是由hash表支持的。这使用hashCdoe与equals来维护元素的唯一
|----TreeSet
对于Set集合，如果想要遍历出所有元素，只能使用迭代器.
元素不重复，是指元素做equals为true,代表重复.
HashSet怎样保证元素唯一
1.两个元素的hashCode不一样，不会判断equals，直接就能装入.
2.两个元素的hashCode一样，equals为false,能装入
3.两个元素的hashCdoe一样，equals为true,不能装入.
做equals相等的对象的hashCode值应该一样.
我们重写hashCode方法时怎样重写
就是将所有的做equals比较进应用的属性的hashCode值进行相加就可以，
为了减少重复的概率，我们可以定义一个质数，用这个质数与
所有的属性相乘，这样使用的hashCode值重复概率减少.

作者: 山西_李帅 时间: 2013-4-15 20:30
这些都是都是我整理过的笔记，希望对你们有帮助啊。

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2