A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

本帖最后由 山西_李帅 于 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  :无顺序不可重复

评分

参与人数 1技术分 +1 收起 理由
田磊阳 + 1

查看全部评分

4 个回复

倒序浏览
抢个沙发 十个字 不到
回复 使用道具 举报
继续更新喽。  这次给大家都附带上每一个方法的例子。
回复 使用道具 举报
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值重复概率减少.
回复 使用道具 举报
这些都是都是我整理过的笔记, 希望对你们有帮助啊。
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马