美文网首页Java笔记
No_16_0311 Java基础学习第十六天

No_16_0311 Java基础学习第十六天

作者: lutianfei | 来源:发表于2016-03-16 16:13 被阅读72次
    文档版本 开发工具 测试平台 工程名字 日期 作者 备注
    V1.0 2016.03.11 lutianfei none

    [TOC]


    ArrayList(List子类)

    ArrayList类概述

    • 底层数据结构是数组查询快,增删慢
    • 线程不安全,效率高
    • 没有什么特殊功能需要学习。

    ArrayList案例

    存储字符串并遍历
    public class ArrayListDemo {
        public static void main(String[] args) {
            // 创建集合对象
            ArrayList array = new ArrayList();
    
            // 创建元素对象,并添加元素
            array.add("hello");
            array.add("world");
            array.add("java");
    
            // 遍历
            Iterator it = array.iterator();
            while (it.hasNext()) {
                String s = (String) it.next();
                System.out.println(s);
            }
    
            System.out.println("-----------");
    
            for (int x = 0; x < array.size(); x++) {
                String s = (String) array.get(x);
                System.out.println(s);
            }
        }
    }
    
    存储自定义对象并遍历
    public class ArrayListDemo2 {
        public static void main(String[] args) {
            // 创建集合对象
            ArrayList array = new ArrayList();
    
            // 创建学生对象
            Student s1 = new Student("武松", 30);
            Student s2 = new Student("鲁智深", 40);
            Student s3 = new Student("林冲", 36);
            Student s4 = new Student("杨志", 38);
    
            // 添加元素
            array.add(s1);
            array.add(s2);
            array.add(s3);
            array.add(s4);
    
            // 遍历
            Iterator it = array.iterator();
            while (it.hasNext()) {
                Student s = (Student) it.next();
                System.out.println(s.getName() + "---" + s.getAge());
            }
    
            System.out.println("----------------");
    
            for (int x = 0; x < array.size(); x++) {
                // ClassCastException 注意,千万要搞清楚类型
                // String s = (String) array.get(x);
                // System.out.println(s);
    
                Student s = (Student) array.get(x);
                System.out.println(s.getName() + "---" + s.getAge());
            }
        }
    }
    

    Vector类

    Vector类概述

    • 底层数据结构是数组,查询快,增删慢
    • 线程安全,效率低

    Vector类特有功能

    • 1:添加功能

      • public void addElement(E obj) <--> add()
    • 2:获取功能

      • public E elementAt(int index) <--> get()
      • public Enumeration elements() <--> Iterator iterator()
        • boolean hasMoreElements() <--> hasNext()
        • Object nextElement() <--> next()
    public class VectorDemo {
        public static void main(String[] args) {
            // 创建集合对象
            Vector v = new Vector();
    
            // 添加功能
            v.addElement("hello");
            v.addElement("world");
            v.addElement("java");
    
            // 遍历
            for (int x = 0; x < v.size(); x++) {
                String s = (String) v.elementAt(x);
                System.out.println(s);
            }
    
            System.out.println("------------------");
    
            Enumeration en = v.elements(); // 返回的是实现类的对象
            while (en.hasMoreElements()) {
                String s = (String) en.nextElement();
                System.out.println(s);
            }
        }
    }
    

    Vector案例(List子类)

    • 存储字符串并遍历
    • 存储自定义对象并遍历

    LinkedList类(List子类)

    LinkedList类概述

    • 底层数据结构是链表查询慢增删快
    • 线程不安全,效率高

    LinkedList类特有功能

    A:添加功能
    • public void addFirst(Object e)
    • public void addLast(Object e)
    B:获取功能
    • public Object getFirst()
    • public Obejct getLast()
    C:删除功能
    • public Object removeFirst()
    • public Object removeLast()
    public class LinkedListDemo {
        public static void main(String[] args) {
            // 创建集合对象
            LinkedList link = new LinkedList();
    
            // 添加元素
            link.add("hello");
            link.add("world");
            link.add("java");
    
            // public void addFirst(Object e)
            // link.addFirst("javaee");
            // public void addLast(Object e)
            // link.addLast("android");
    
            // public Object getFirst()
            // System.out.println("getFirst:" + link.getFirst());
            // public Obejct getLast()
            // System.out.println("getLast:" + link.getLast());
    
            // public Object removeFirst()
            System.out.println("removeFirst:" + link.removeFirst());
            // public Object removeLast()
            System.out.println("removeLast:" + link.removeLast());
    
            // 输出对象名
            System.out.println("link:" + link);
        }
    }
    

    LinkedList案例

    • 存储字符串并遍历
    • 存储自定义对象并遍历

    练习题1:

    • ArrayList去除集合中字符串的重复值(字符串的内容相同)
    import java.util.ArrayList;
    import java.util.Iterator;
    
    /*
     * ArrayList去除集合中字符串的重复值(字符串的内容相同)
     * 
     * 分析:
     *         A:创建集合对象
     *         B:添加多个字符串元素(包含内容相同的)
     *         C:创建新集合
     *         D:遍历旧集合,获取得到每一个元素
     *         E:拿这个元素到新集合去找,看有没有
     *             有:不搭理它
     *             没有:就添加到新集合
     *         F:遍历新集合
     */
    public class ArrayListDemo {
        public static void main(String[] args) {
            // 创建集合对象
            ArrayList array = new ArrayList();
    
            // 添加多个字符串元素(包含内容相同的)
            array.add("hello");
            array.add("world");
            array.add("java");
            array.add("world");
            array.add("java");
            array.add("world");
            array.add("world");
            array.add("world");
            array.add("world");
            array.add("java");
            array.add("world");
    
            // 创建新集合
            ArrayList newArray = new ArrayList();
    
            // 遍历旧集合,获取得到每一个元素
            Iterator it = array.iterator();
            while (it.hasNext()) {
                String s = (String) it.next();
                // 拿这个元素到新集合去找,看有没有
                if (!newArray.contains(s)) {
                    newArray.add(s);
                }
            }
    
            // 遍历新集合
            for (int x = 0; x < newArray.size(); x++) {
                String s = (String) newArray.get(x);
                System.out.println(s);
            }
            
            //方法2:
            //        for (int x = 0; x < array.size() - 1; x++) {
            //    for (int y = x + 1; y < array.size(); y++) {
            //        if (array.get(x).equals(array.get(y))) {
            //            array.remove(y);
            //            y--;
            //        }
            //    }
            //}
    
            // 遍历集合
            //Iterator it = array.iterator();
            //while (it.hasNext()) {
            //    String s = (String) it.next();
            //    System.out.println(s);
            //}
        }
    }
    

    练习题2:

    • 去除集合中自定义对象的重复值(对象的成员变量值都相同)
    • 重载equals的方法alt+shift+s+h
    import java.util.ArrayList;
    import java.util.Iterator;
    
    /*
     * 需求:去除集合中自定义对象的重复值(对象的成员变量值都相同)
     * 
     * 我们按照和字符串一样的操作,发现出问题了。
     * 为什么呢?
     *         我们必须思考哪里会出问题?
     *         通过简单的分析,我们知道问题出现在了判断上。
     *         而这个判断功能是集合自己提供的,所以我们如果想很清楚的知道它是如何判断的,就应该去看源码。
     * contains()方法的底层依赖的是equals()方法。
     * 而我们的学生类中没有equals()方法,这个时候,默认使用的是它父亲Object的equals()方法
     * Object()的equals()默认比较的是地址值,所以,它们进去了。因为new的东西,地址值都不同。
     * 按照我们自己的需求,比较成员变量的值,重写equals()即可。
     * 自动生成即可。
     */
    public class ArrayListDemo3 {
        public static void main(String[] args) {
            // 创建集合对象
            ArrayList array = new ArrayList();
    
            // 创建学生对象
            Student s1 = new Student("林青霞", 27);
            Student s2 = new Student("林志玲", 40);
            Student s3 = new Student("凤姐", 35);
            Student s4 = new Student("芙蓉姐姐", 18);
            Student s5 = new Student("翠花", 16);
            Student s6 = new Student("林青霞", 27);
            Student s7 = new Student("林青霞", 18);
    
            // 添加元素
            array.add(s1);
            array.add(s2);
            array.add(s3);
            array.add(s4);
            array.add(s5);
            array.add(s6);
            array.add(s7);
    
            // 创建新集合
            ArrayList newArray = new ArrayList();
    
            // 遍历旧集合,获取得到每一个元素
            Iterator it = array.iterator();
            while (it.hasNext()) {
                Student s = (Student) it.next();
    
                // 拿这个元素到新集合去找,看有没有
                if (!newArray.contains(s)) {
                    newArray.add(s);
                }
            }
    
            // 遍历新集合
            for (int x = 0; x < newArray.size(); x++) {
                Student s = (Student) newArray.get(x);
                System.out.println(s.getName() + "---" + s.getAge());
            }
        }
    }
    

    练习3:

    • 用LinkedList模拟栈数据结构的集合,并测试
    public class MyStackDemo {
        public static void main(String[] args) {
            // 创建集合对象
            MyStack ms = new MyStack();
    
            // 添加元素
            ms.add("hello");
            ms.add("world");
            ms.add("java");
    
            // System.out.println(ms.get());
            // System.out.println(ms.get());
            // System.out.println(ms.get());
            // NoSuchElementException
            // System.out.println(ms.get());
            
            while(!ms.isEmpty()){
                System.out.println(ms.get());
            }
        }
    }
    
    
    
    public class MyStack {
        private LinkedList link;
    
        public MyStack() {
            link = new LinkedList();
        }
    
        public void add(Object obj) {
            link.addFirst(obj);
        }
    
        public Object get() {
            // return link.getFirst();
            return link.removeFirst();
        }
    
        public boolean isEmpty() {
            return link.isEmpty();
        }
    }
    

    泛型

    • 类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型参数化类型,把类型当作参数一样的传递。
    • 泛型出现的原因
    • 泛型出现的好处
      • A:把运行时期的问题提前到了编译期间
      • B:避免了强制类型转换
      • C:优化了程序设计,解决了黄色警告线
    • 泛型的书写格式
      • <数据类型>
      • 此处的数据类型只能是引用类型
    public class GenericDemo {
        public static void main(String[] args) {
            // 创建
            ArrayList<String> array = new ArrayList<String>();
    
            // 添加元素
            array.add("hello");
            array.add("world");
            array.add("java");
            // array.add(new Integer(100));
            //array.add(10); // JDK5以后的自动装箱
            // 等价于:array.add(Integer.valueOf(10));
    
            // 遍历
            Iterator<String> it = array.iterator();
            while (it.hasNext()) {
                // ClassCastException
                // String s = (String) it.next();
                String s = it.next();
                System.out.println(s);
            }
    
        }
    }
    
    /*
     * 需求:存储自定义对象并遍历。
     * 
     * A:创建学生类
     * B:创建集合对象
     * C:创建元素对象
     * D:把元素添加到集合
     * E:遍历集合
     */
    public class ArrayListDemo2 {
        public static void main(String[] args) {
            // 创建集合对象
            // JDK7的新特性:泛型推断。
            // ArrayList<Student> array = new ArrayList<>();
            // 但是我不建议这样使用。
            ArrayList<Student> array = new ArrayList<Student>();
    
            // 创建元素对象
            Student s1 = new Student("曹操", 40); // 后知后觉
            Student s2 = new Student("蒋干", 30); // 不知不觉
            Student s3 = new Student("诸葛亮", 26);// 先知先觉
    
            // 添加元素
            array.add(s1);
            array.add(s2);
            array.add(s3);
    
            // 遍历
            Iterator<Student> it = array.iterator();
            while (it.hasNext()) {
                Student s = it.next();
                System.out.println(s.getName() + "---" + s.getAge());
            }
            System.out.println("------------------");
    
            for (int x = 0; x < array.size(); x++) {
                Student s = array.get(x);
                System.out.println(s.getName() + "---" + s.getAge());
            }
        }
    }
    

    泛型由来

    • 为什么会有泛型呢?
      • 早期的Object类型可以接收任意的对象类型,但是在实际的使用中,会有类型转换的问题。也就存在这隐患,所以Java提供了泛型来解决这个安全问题。
    • 通过案例引入
    /*
     * 早期的时候,我们使用Object来代表任意的类型。
     * 向上转型是没有任何问题的,但是在向下转型的时候其实隐含了类型转换的问题。
     * 也就是说这样的程序其实并不是安全的。所以Java在JDK5后引入了泛型,提高程序的安全性。
     */
    public class ObjectToolDemo {
        public static void main(String[] args) {
            ObjectTool ot = new ObjectTool();
    
            // 正常使用
            ot.setObj(new Integer(27));
            Integer i = (Integer) ot.getObj();
            System.out.println("年龄是:" + i);
    
            ot.setObj(new String("林青霞"));
            String s = (String) ot.getObj();
            System.out.println("姓名是:" + s);
    
            System.out.println("---------");
            ot.setObj(new Integer(30));
            // ClassCastException
            String ss = (String) ot.getObj();
            System.out.println("姓名是:" + ss);
        }
    }
    

    泛型应用(集合中使用)

    • 泛型
      • 把泛型定义在类上
      • 格式:public class 类名<泛型类型1,…>
      • 注意:泛型类型必须是引用类型
    • 泛型方法
      • 把泛型定义在方法上
      • 格式:public <泛型类型> 返回类型 方法名(泛型类型 .)
    • 泛型接口
      • 把泛型定义在接口上
      • 格式:public interface 接口名<泛型类型1…>
    泛型类案例
    
    /*
     * 泛型类:把泛型定义在类上
     */
    public class ObjectTool<T> {
        private T obj;
    
        public T getObj() {
            return obj;
        }
    
        public void setObj(T obj) {
            this.obj = obj;
        }
    }
    
    public class ObjectToolDemo {
        public static void main(String[] args) {
            // 泛型类错误用法
            // ObjectTool ot = new ObjectTool();
            //
            // ot.setObj(new String("风清扬"));
            // String s = (String) ot.getObj();
            // System.out.println("姓名是:" + s);
            //
            // ot.setObj(new Integer(30));
            // Integer i = (Integer) ot.getObj();
            // System.out.println("年龄是:" + i);
    
            // ot.setObj(new String("林青霞"));
            // // ClassCastException
            // Integer ii = (Integer) ot.getObj();
            // System.out.println("姓名是:" + ii);
    
            System.out.println("-------------");
    
            ObjectTool<String> ot = new ObjectTool<String>();
            // ot.setObj(new Integer(27)); //这个时候编译期间就过不去
            ot.setObj(new String("林青霞"));
            String s = ot.getObj();
            System.out.println("姓名是:" + s);
    
            ObjectTool<Integer> ot2 = new ObjectTool<Integer>();
            // ot2.setObj(new String("风清扬"));//这个时候编译期间就过不去
            ot2.setObj(new Integer(27));
            Integer i = ot2.getObj();
            System.out.println("年龄是:" + i);
        }
    }
    
    泛型方法案例
    public class ObjectTool {
        public <T> void show(T t) {
            System.out.println(t);
        }
    }
    
    
    public class ObjectToolDemo {
        public static void main(String[] args) {
            // ObjectTool ot = new ObjectTool();
            // ot.show("hello");
            // ot.show(100);
            // ot.show(true);
    
            // ObjectTool<String> ot = new ObjectTool<String>();
            // ot.show("hello");
            //
            // ObjectTool<Integer> ot2 = new ObjectTool<Integer>();
            // ot2.show(100);
            //
            // ObjectTool<Boolean> ot3 = new ObjectTool<Boolean>();
            // ot3.show(true);
    
            // 如果还听得懂,那就说明泛型类是没有问题的
            // 但是呢,谁说了我的方法一定要和类的类型的一致呢?
            // 我要是类上没有泛型的话,方法还能不能接收任意类型的参数了呢?
    
            // 定义泛型方法后
            ObjectTool ot = new ObjectTool();
            ot.show("hello");
            ot.show(100);
            ot.show(true);
        }
    }
    
    泛型接口案例
    /*
     * 泛型接口:把泛型定义在接口上
     */
    public interface Inter<T> {
        public abstract void show(T t);
    }
    
    
    //实现类在实现接口的时候
    //第一种情况:已经知道该是什么类型的了
    
    //public class InterImpl implements Inter<String> {
    //
    //    @Override
    //    public void show(String t) {
    //        System.out.println(t);
    //    }
    // }
    
    //第二种情况:还不知道是什么类型的
    public class InterImpl<T> implements Inter<T> {
    
        @Override
        public void show(T t) {
            System.out.println(t);
        }
    }
    
    
    public class InterDemo {
        public static void main(String[] args) {
            // 第一种情况的测试
            // Inter<String> i = new InterImpl();
            // i.show("hello");
    
            // // 第二种情况的测试
            Inter<String> i = new InterImpl<String>();
            i.show("hello");
    
            Inter<Integer> ii = new InterImpl<Integer>();
            ii.show(100);
        }
    }
    
    

    泛型高级(通配符)

    • 泛型通配符<?>
      • 任意类型,如果没有明确,那么就是Object以及任意的Java类了
    • <? extends E>
      • 向下限定,E及其子类
    • <? super E>
      • 向上限定,E及其父类
    /*
     * 泛型高级(通配符)
     * ?:任意类型,如果没有明确,那么就是Object以及任意的Java类了
     * ? extends E:向下限定,E及其子类
     * ? super E:向上限定,E极其父类
     */
    public class GenericDemo {
        public static void main(String[] args) {
            // 泛型如果明确的写的时候,前后必须一致
            Collection<Object> c1 = new ArrayList<Object>();
            // Collection<Object> c2 = new ArrayList<Animal>();
            // Collection<Object> c3 = new ArrayList<Dog>();
            // Collection<Object> c4 = new ArrayList<Cat>();
    
            // ?表示任意的类型都是可以的
            Collection<?> c5 = new ArrayList<Object>();
            Collection<?> c6 = new ArrayList<Animal>();
            Collection<?> c7 = new ArrayList<Dog>();
            Collection<?> c8 = new ArrayList<Cat>();
    
            // ? extends E:向下限定,E及其子类
            // Collection<? extends Animal> c9 = new ArrayList<Object>();
            Collection<? extends Animal> c10 = new ArrayList<Animal>();
            Collection<? extends Animal> c11 = new ArrayList<Dog>();
            Collection<? extends Animal> c12 = new ArrayList<Cat>();
    
            // ? super E:向上限定,E极其父类
            Collection<? super Animal> c13 = new ArrayList<Object>();
            Collection<? super Animal> c14 = new ArrayList<Animal>();
            // Collection<? super Animal> c15 = new ArrayList<Dog>();
            // Collection<? super Animal> c16 = new ArrayList<Cat>();
        }
    }
    
    class Animal {
    }
    
    class Dog extends Animal {
    }
    
    class Cat extends Animal {
    }
    

    增强for

    增强for概述

    • 简化数组和Collection集合的遍历

    • 格式:

      • for(元素数据类型 变量 : 数组或者Collection集合) {
        使用变量即可,该变量就是元素
        }
    • 好处:简化数组或集合的遍历

    • 注意事项:增强for的目标要判断是否为null(不能为null)

      • 使用前判断是否为null
    • 把前面的集合代码的遍历用增强for改进

    • Eg1:

    /*
     * JDK5的新特性:自动拆装箱,泛型,增强for,静态导入,可变参数,枚举
     * 
     * 增强for:是for循环的一种。
     * 
     * 格式:
     *         for(元素数据类型 变量 : 数组或者Collection集合) {
     *            使用变量即可,该变量就是元素
     *       }
     *   
     * 好处:简化了数组和集合的遍历。
     * 
     * 弊端: 增强for的目标不能为null。
     * 如何解决呢?对增强for的目标先进行不为null的判断,然后在使用。
     */
    public class ForDemo {
        public static void main(String[] args) {
            // 定义一个int数组
            int[] arr = { 1, 2, 3, 4, 5 };
            for (int x = 0; x < arr.length; x++) {
                System.out.println(arr[x]);
            }
            System.out.println("---------------");
            // 增强for
            for (int x : arr) {
                System.out.println(x);
            }
            System.out.println("---------------");
            // 定义一个字符串数组
            String[] strArray = { "林青霞", "风清扬", "东方不败", "刘意" };
            // 增强for
            for (String s : strArray) {
                System.out.println(s);
            }
            System.out.println("---------------");
            // 定义一个集合
            ArrayList<String> array = new ArrayList<String>();
            array.add("hello");
            array.add("world");
            array.add("java");
            // 增强for
            for (String s : array) {
                System.out.println(s);
            }
            System.out.println("---------------");
    
            List<String> list = null;
            // NullPointerException
            // 这个s是我们从list里面获取出来的,在获取前,它肯定还好做一个判断
            // 说白了,这就是迭代器的功能
            if (list != null) {
                for (String s : list) {
                    System.out.println(s);
                }
            }
    
            // 增强for其实是用来替代迭代器的
            //ConcurrentModificationException
            // for (String s : array) {
            // if ("world".equals(s)) {
            // array.add("javaee");
            // }
            // }
            // System.out.println("array:" + array);
        }
    }
    
    • Eg2:
    import java.util.ArrayList;
    import java.util.Iterator;
    
    /*
     * ArrayList存储字符串并遍历。要求加入泛型,并用增强for遍历。
     * A:迭代器
     * B:普通for
     * C:增强for
     */
    public class ArrayListDemo {
        public static void main(String[] args) {
            // 创建集合对象
            ArrayList<String> array = new ArrayList<String>();
    
            // 创建并添加元素
            array.add("hello");
            array.add("world");
            array.add("java");
    
            // 遍历集合
            // 迭代器
            Iterator<String> it = array.iterator();
            while (it.hasNext()) {
                String s = it.next();
                System.out.println(s);
            }
            System.out.println("------------------");
    
            // 普通for
            for (int x = 0; x < array.size(); x++) {
                String s = array.get(x);
                System.out.println(s);
            }
            System.out.println("------------------");
    
            // 增强for
            for (String s : array) {
                System.out.println(s);
            }
        }
    }
    
    • Eg3:(<font color = red>必会</font>)
    import java.util.ArrayList;
    import java.util.Iterator;
    
    /*
     * 需求:ArrayList存储自定义对象并遍历。要求加入泛型,并用增强for遍历。
     * A:迭代器
     * B:普通for
     * C:增强for
     * 
     * LinkedList,Vector,Colleciton,List等存储我还讲吗?不讲解了,但是要求你们练习。
     * 
     * 增强for是用来替迭代器。
     */
    public class ArrayListDemo2 {
        public static void main(String[] args) {
            // 创建集合对象
            ArrayList<Student> array = new ArrayList<Student>();
    
            // 创建学生对象
            Student s1 = new Student("林青霞", 27);
            Student s2 = new Student("貂蝉", 22);
            Student s3 = new Student("杨玉环", 24);
            Student s4 = new Student("西施", 21);
            Student s5 = new Student("王昭君", 23);
    
            // 把学生对象添加到集合中
            array.add(s1);
            array.add(s2);
            array.add(s3);
            array.add(s4);
            array.add(s5);
    
            // 迭代器
            Iterator<Student> it = array.iterator();
            while (it.hasNext()) {
                Student s = it.next();
                System.out.println(s.getName() + "---" + s.getAge());
            }
            System.out.println("---------------");
    
            // 普通for
            for (int x = 0; x < array.size(); x++) {
                Student s = array.get(x);
                System.out.println(s.getName() + "---" + s.getAge());
            }
            System.out.println("---------------");
    
            // 增强for
            for (Student s : array) {
                System.out.println(s.getName() + "---" + s.getAge());
            }
        }
    }
    

    静态导入

    静态导入概述

    • 格式:import static 包名….类名.方法名;
    • 可以直接导入到方法的级别

    注意事项

    • 方法必须是静态的
    • 如果有多个同名的静态方法,这个时候要使用,必须加前缀。所以一般不用,但是要能看懂。
    /*
     * 静态导入:
     * 格式:import static 包名….类名.方法名;
     * 可以直接导入到方法的级别
     * 
     * 静态导入的注意事项:
     *         A:方法必须是静态的
     *         B:如果有多个同名的静态方法,容易不知道使用谁?这个时候要使用,必须加前缀。由此可见,意义不大,所以一般不用,但是要能看懂。
     */
    import static java.lang.Math.abs;
    import static java.lang.Math.pow;
    import static java.lang.Math.max;
    
    //错误
    //import static java.util.ArrayList.add;
    
    public class StaticImportDemo {
        public static void main(String[] args) {
            // System.out.println(java.lang.Math.abs(-100));
            // System.out.println(java.lang.Math.pow(2, 3));
            // System.out.println(java.lang.Math.max(20, 30));
            // 太复杂,我们就引入到import
    
            // System.out.println(Math.abs(-100));
            // System.out.println(Math.pow(2, 3));
            // System.out.println(Math.max(20, 30));
            // 太复杂,有更简单
    
    //        System.out.println(abs(-100));
            System.out.println(java.lang.Math.abs(-100));
            System.out.println(pow(2, 3));
            System.out.println(max(20, 30));
        }
        
        public static void abs(String s){
            System.out.println(s);
        }
    }
    

    提取生成方法

    • step1:选中右键


    • step2:选择:Refactor --> Extract Method...


    • step3 :生成所需方法
      [站外图片上传中……(3)]

    • 结果如下:
      [站外图片上传中……(4)]
      [站外图片上传中……(5)]


    可变参数

    可变参数概述

    • 定义方法的时候不知道该定义多少个参数

    格式

    • 修饰符 返回值类型 方法名(数据类型 变量名){}
    • 注意:
      • 这里的变量其实是一个数组名
      • 如果一个方法有可变参数,并且有多个参数,那么,可变参数肯定是最后一个
    /*
     * 可变参数:定义方法的时候不知道该定义多少个参数
     * 格式:
     *         修饰符 返回值类型 方法名(数据类型…  变量名){
     * 
     *         }
     * 
     *         注意:
     *             这里的变量其实是一个数组
     *             如果一个方法有可变参数,并且有多个参数,那么,可变参数肯定是最后一个
     */                
    public class ArgsDemo {
        public static void main(String[] args) {
    
            // 需求:我要写一个求和的功能,到底是几个数据求和呢,我不太清楚,但是我知道在调用的时候我肯定就知道了
            // 为了解决这个问题,Java就提供了一个东西:可变参数
            result = sum(a, b, c, d, 40);
            System.out.println("result:" + result);
    
            result = sum(a, b, c, d, 40, 50);
            System.out.println("result:" + result);
        }
    
        public static int sum(int... a) {
            // System.out.println(a);
            //return 0;
    
            int s = 0;
            
            for(int x : a){
                s +=x;
            }
            
            return s;
        }
    
    }
    

    Arrays工具类中的把数组转集合的方法

    • public static <T> List<T> asList(T ... a)
      • 功能:把数组转集合
      • 注意事项:虽然可以把数组转成集合,但是集合的长度不能改变。
    /*
     * public static <T> List<T> asList(T... a):把数组转成集合
     * 
     * 注意事项:
     *         虽然可以把数组转成集合,但是集合的长度不能改变。
     */
    public class ArraysDemo {
        public static void main(String[] args) {
            // 定义一个数组
            // String[] strArray = { "hello", "world", "java" };
            // List<String> list = Arrays.asList(strArray);
    
            List<String> list = Arrays.asList("hello", "world", "java");
            // UnsupportedOperationException
            // list.add("javaee");
            // UnsupportedOperationException
            // list.remove(1);
            list.set(1, "javaee");
    
            for (String s : list) {
                System.out.println(s);
            }
        }
    }
    

    List集合练习(重要)

    • 集合的嵌套遍历
    import java.util.ArrayList;
    
    /*
     * 集合的嵌套遍历
     * 需求:
     *         我们班有学生,每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList<Student>
     *         但是呢,我们旁边是不是还有班级,每个班级是不是也是一个ArrayList<Student>。
     *         而我现在有多个ArrayList<Student>。也要用集合存储,怎么办呢?
     *         就是这个样子的:ArrayList<ArrayList<Student>>
     */
    public class ArrayListDemo {
        public static void main(String[] args) {
            // 创建大集合
            ArrayList<ArrayList<Student>> bigArrayList = new ArrayList<ArrayList<Student>>();
    
            // 创建第一个班级的学生集合
            ArrayList<Student> firstArrayList = new ArrayList<Student>();
            // 创建学生
            Student s1 = new Student("唐僧", 30);
            Student s2 = new Student("孙悟空", 29);
            Student s3 = new Student("猪八戒", 28);
            Student s4 = new Student("沙僧", 27);
            Student s5 = new Student("白龙马", 26);
            // 学生进班
            firstArrayList.add(s1);
            firstArrayList.add(s2);
            firstArrayList.add(s3);
            firstArrayList.add(s4);
            firstArrayList.add(s5);
            // 把第一个班级存储到学生系统中
            bigArrayList.add(firstArrayList);
    
            // 创建第二个班级的学生集合
            ArrayList<Student> secondArrayList = new ArrayList<Student>();
            // 创建学生
            Student s11 = new Student("诸葛亮", 30);
            Student s22 = new Student("司马懿", 28);
            Student s33 = new Student("周瑜", 26);
            // 学生进班
            secondArrayList.add(s11);
            secondArrayList.add(s22);
            secondArrayList.add(s33);
            // 把第二个班级存储到学生系统中
            bigArrayList.add(secondArrayList);
    
            // 创建第三个班级的学生集合
            ArrayList<Student> thirdArrayList = new ArrayList<Student>();
            // 创建学生
            Student s111 = new Student("宋江", 40);
            Student s222 = new Student("吴用", 35);
            Student s333 = new Student("高俅", 30);
            Student s444 = new Student("李师师", 22);
            // 学生进班
            thirdArrayList.add(s111);
            thirdArrayList.add(s222);
            thirdArrayList.add(s333);
            thirdArrayList.add(s444);
            // 把第三个班级存储到学生系统中
            bigArrayList.add(thirdArrayList);
    
            // 遍历集合
            for (ArrayList<Student> array : bigArrayList) {
                for (Student s : array) {
                    System.out.println(s.getName() + "---" + s.getAge());
                }
            }
        }
    }
    
    • 获取10个1-20之间的随机数,要求不能重复
    /*
     * 获取10个1-20之间的随机数,要求不能重复
     * 
     * 用数组实现,但是数组的长度是固定的,长度不好确定。
     * 所以我们使用集合实现。
     * 
     * 分析:
     *         A:创建产生随机数的对象
     *         B:创建一个存储随机数的集合。
     *         C:定义一个统计变量。从0开始。
     *         D:判断统计遍历是否小于10
     *             是:先产生一个随机数,判断该随机数在集合中是否存在。
     *                     如果不存在:就添加,统计变量++。
     *                     如果存在:就不搭理它。
     *             否:不搭理它
     *         E:遍历集合
     */
    public class RandomDemo {
        public static void main(String[] args) {
            // 创建产生随机数的对象
            Random r = new Random();
    
            // 创建一个存储随机数的集合。
            ArrayList<Integer> array = new ArrayList<Integer>();
    
            // 定义一个统计变量。从0开始。
            int count = 0;
    
            // 判断统计遍历是否小于10
            while (count < 10) {
                //先产生一个随机数
                int number = r.nextInt(20) + 1;
                
                //判断该随机数在集合中是否存在。
                if(!array.contains(number)){
                    //如果不存在:就添加,统计变量++。
                    array.add(number);
                    count++;
                }
            }
            
            //遍历集合
            for(Integer i : array){
                System.out.println(i);
            }
        }
    }
    
    
    • 键盘录入多个数据,以0结束,要求在控制台输出这多个数据中的最大值
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Scanner;
    
    /*
     * 键盘录入多个数据,以0结束,要求在控制台输出这多个数据中的最大值
     * 
     * 分析:
     *         A:创建键盘录入数据对象
     *         B:键盘录入多个数据,我们不知道多少个,所以用集合存储
     *         C:以0结束,这个简单,只要键盘录入的数据是0,我就不继续录入数据了
     *         D:把集合转成数组
     *         E:对数组排序
     *         F:获取该数组中的最大索引的值
     */
    public class ArrayListDemo {
        public static void main(String[] args) {
            // 创建键盘录入数据对象
            Scanner sc = new Scanner(System.in);
    
            // 键盘录入多个数据,我们不知道多少个,所以用集合存储
            ArrayList<Integer> array = new ArrayList<Integer>();
    
            // 以0结束,这个简单,只要键盘录入的数据是0,我就不继续录入数据了
            while (true) {
                System.out.println("请输入数据:");
                int number = sc.nextInt();
                if (number != 0) {
                    array.add(number);
                } else {
                    break;
                }
            }
    
            // 把集合转成数组
            // public <T> T[] toArray(T[] a)
            Integer[] i = new Integer[array.size()];
            // Integer[] ii = array.toArray(i);
            array.toArray(i);
            // System.out.println(i);
            // System.out.println(ii); //i,ii地址值是同一个!
    
            // 对数组排序
            // public static void sort(Object[] a)
            Arrays.sort(i);
    
            // 获取该数组中的最大索引的值
            System.out.println("数组是:" + arrayToString(i) + "最大值是:"
                    + i[i.length - 1]);
        }
    
        public static String arrayToString(Integer[] i) {
            StringBuilder sb = new StringBuilder();
    
            sb.append("[");
            for (int x = 0; x < i.length; x++) {
                if (x == i.length - 1) {
                    sb.append(i[x]);
                } else {
                    sb.append(i[x]).append(", ");
                }
            }
            sb.append("]");
    
            return sb.toString();
        }
    }
    

    相关文章

      网友评论

        本文标题:No_16_0311 Java基础学习第十六天

        本文链接:https://www.haomeiwen.com/subject/eiwqlttx.html