6.4.1基本数据类型的对象包装类

                   1) Integer常用静态方法:

                   //查看Integer最大数

       System.out.println(Integer.MAX_VALUE);

       //查看Integer最小数

       System.out.println(Integer.MIN_VALUE);

       //查看Double最大数

       System.out.println(Double.MAX_VALUE);

       //查看Double最小数

       System.out.println(Double.MIN_VALUE);

       //整数转换成2进制

       System.out.println(Integer.toBinaryString(200));

       //整数转换成8进制

       System.out.println(Integer.toOctalString(100));

       //整数转换成16进制

       System.out.println(Integer.toHexString(169));

       //字符串转换成数字(字符串必须是数字格式,否则抛异常)

       代码样式:Integer.parseInt(String);

       Strings = "1234565";

       inti = Integer.parseInt(s);

       System.out.println(i);

       //数字格式字符串转换成整型,"110"代表数字格式字符串,2代表字符串数字的格式(),最终装换成10进制数

       代码样式:Integer.parseInt(String,Int);

       System.out.println(Integer.parseInt("110",2));

        2) JDK1.5新特性Integer自动拆装过程(面试题)

       Integer i = 40;// Integer i = new Integer(40);自动装箱

       i= i + 10;

       //i= i.intValue()+ 10(自动拆箱)i= 50 new Integet(50)自动装箱

       System.out.println(i);//结果50

       3) 两个Integer对象在byte取值范围内比较则使用同一地址空间,如果超过byte就分别使用不同的地址空间.

       Integer ii = 127;

       Integerjj = 127;

       ii==jj//结果为true

       Integerii = 128;

       Integerjj = 128;

       ii==jj//结果为false

6.4.2 集合类

                   1) 集合是存储对象的一种方式,一种容器,存在集合内的元素都转成Object.

                   2) 集合与数组的区别:

                            1,可以存储对象,但是长度是固定的, 集合的长度是可变的.

                            2,数组可以存储基本数据类型,集合只能存储对象.

                   3) 集合的特点:

                   集合只存储对象,长度是可变的,可以存储不同类型的对象.

                   4) 集合的构成及分类

                 

                   5) Collection常用功能(使用Collection接口需要先导入java.util.*包)

                            1, 包含两个子接口(List,Set)

                            2,List: 元素有序,取出顺序元素顺序一致;可以存储重复元素;元素有下标

                            3,List常用子类:ArrayList,LinkedList,Vector

                              ArrayList底层是数组结构,查询速度快,增删慢,线程不同步.

                              LinkedList底层是链表结构,查询速度慢,增删快

                              Vector底层是数组结构,线程同步

                   //父类引用指向子类对象

       Collectionc = new ArrayList();

       Collectioncc = new ArrayList();

       //集合中添加数据

       //添加元素,如果添加成功返回true,反之false

       c.add("abc1");

       //将cc集合中所有元素添加到c集合中

       c.addAll(cc);

       //打印集合长度

       System.out.println(c.size());

       //打印集合,可直接打印

       System.out.println(c);

       //查找集合是否包含一模一样的元素,有则返回true

       b= c.contains("abc3");

       //判断cc跟c中是否有一部分相同,有就返回true

       b= c.containsAll(cc);

       //集合中移除元素,移除成功返回true

       b= c.remove("abc1");

       //删除c集合中和cc相同的元素,移除成功返回true(cc中元素不变)

       b= c.removeAll(cc);

       //保留c和cc中相同的元素(cc元素不变),如果有相同元素则返回true

       b= c.retainAll(cc);

6) 迭代器Iterator
      迭代器的建立:

        格式: 迭代器接口变量名 = 集合.iterator()方法,返回值是内存地址

            Iterator i1 = c.iterator();

        迭代器取值运行中删除集合元素:

        //hasNext下一个是否有元素,有就返回true

        while (i1.hasNext()){

        //迭代返回的值强制转换成String类型

        String s = (String)i1.next();

        //判断集合内的元素是否跟abc1相同,如果相同则删除

        if ("abc1".equals(s)){

            i1.remove();

        }

            System.out.println(s); //打印没删除前的集合

        }

        System.out.println(c1); //打印删除后的集合

        迭代器取自定义类:

            //创建一个集合

        Collection c = new ArrayList();

        //对集合c内通过构造函数添加元素

        c.add(new Person1("zhangsan",23));

        c.add(new Person1("lisi",24));

        //创建迭代器

        Iterator i = c.iterator();

        //使用hasNext判断下一个元素是否存在

        while (i.hasNext()){

            //对构造器进行强制类型转换

            Person1 p = (Person1)i.next();

            System.out.println(p.getName()+"..."+p.getAge());

        }

      

7)List
        //创建一个集合

        List l1 = new ArrayList();

        List l2 = new ArrayList();

        //在集合中添加数据

        l1.add("a1");

        l1.add("a2");

        l1.add("a3");

        l2.add("a2");

        l2.add("aaa");

        //指定位置添加元素

        l1.add(1,"aa");

        //将l2集合内的所有元素在l1中添加.l2集合不变

        l1.addAll(l2);

        //指定位置添加l2集合中的元素.

        l1.addAll(1,l2);

        System.out.println(l1);

        //清空集合中的所有元素

        l1.clear();

        System.out.println(l1);

        //判断l1中是否有是否包含这个字符串,,如果有就返回true

        boolean b = l1.contains("a2");

        //判断l1中包含l2集合中所有的元素,如果包括返回true

        b = l1.containsAll(l2);

        //get方法查看集合中指定的元素

        System.out.println(l1.get(2));

        //创建迭代器

        Iterator i = l1.iterator();

        while (i.hasNext()){

            //将集合的元素强制转换成String类型字符串

            String s = (String)i.next();

            System.out.println(s);

        }

      

8)ListIterator List特有迭代器

          //创建一个LinkedList集合

       LinkedListlink = new LinkedList();

       //用addFirst在LinkedList集合最前面添加元素

       link.addFirst("link1!!!!");

       link.addFirst("link2!!!!");

       link.addFirst("link3!!!!");

       //用addFirst在LinkedList集合的最后面添加元素

       link.addLast("Link5!!");

       //创建ListIterator迭代器

       java.util.ListIteratorlt = link.listIterator();

       //判断下一个元素是否存在

       while(lt.hasNext()){

           Strings = (String)lt.next();

           //迭代查询的过程中添加元素

           if ("link1!!!!".equals(s)){

           lt.add("Link4!!!");}

           //迭代查询过程中更改元素

           if ("link3!!!!".equals(s)){

              lt.set("link4!!!!");

              }

       }

//hasPrevious方法判断逆向遍历是否有元素,前提要正向遍历一遍后才可以

       while(lt.hasPrevious()){

           //返回列表中的前一个元素

           Strings = (String)lt.previous();

           System.out.println(s);

       }

呵呵不错继续努力老兄