带你走进java-第十二章.权限,Arrays类的基本方法,包装类的自动装箱和自动拆箱, 可变字符串类,集合

权限

**权限修饰符**
1.  public (公开的)
2.  protected (受保护的)
3.  default (默认的): 什么权限修饰符都不写,就是默认的.若是写了default,会报错
4.  private (私人的)

Arrays类的基本方法

1.Arrays类  是操作数组的工具类  方法都是静态方法
 所以方法的调用 是 类名.方法名();

//  1.数组排序   Arrays.sort();
    String[] str={"nba","abc","cba","aaaa","z","qq"};
    // 数组排序 ( 默认升序 )
    Arrays.sort(str);
// 2.打印数组 Arrays.toString()
    System.out.println(Arrays.toString(str));
//  3.数组二分查找 ( 前提:数组是有序的数组 )
    int[] array1 = {11,22,33,44,55};
    // 若查找的数不存在
    // 假如查找34,返回 - ( 在数组中位置 + 1 ),则为 -(3 + 1) = -4;
    int key = 33;
    // 二分查找
    int index = Arrays.binarySearch(array1, key);
    System.out.println(index);

包装类 ##

1.   基本数据类型  的  包装类 
     byte                    Byte
     short                   Short
     int                     Integer      *
     long                    Long
     float                   Float
     double                  Double
     char                    Character    *
     boolean                 Boolean

基本数据类型的作用:  声明变量    (目的:保存数据)
基本数据类  转换  包装类 :   增加成员变量和成员方法
Integer ( int 的 包装类)     类中     有进制转换的方法

//  1.Integer包装类 转 字符串  , Integer.toString();
      // 创建Integer对象,保存int值 10
      Integer integer = new  Integer(10); 
      // 将Integer对象转换成字符串打印
      System.out.println(integer.toString());
//  2.将字符串 转换成 Integer对象  , new  Integer(string);
      (注意: 只有 数字格式的字符串,才能转换成Integer对象)
      // 否则出现 NumberFormatException异常
      Integer i = new Integer("123");
//  3.将Integer类型  转化为  int类型 , Integer对象.intValue();
     int num = i.intValue();
//  4.将int类型  转换为  Integer类型 ,  Integer类名.valueOf();
     Integer i2 = Integer.valueOf(num);

    **Integer类型 与 int类型的相互自动转化**
    jdk1.5   自动装箱(调用valueOf()) 和 自动拆箱(调用intValue()) 
    // 自动装箱   系统帮你调用了valueOf方法
    Integer n = 10;// Integer.valueOf(10);
    System.out.println(n);
    // 自动拆箱   系统帮你调用了intvalue方法
    int r = n + 15;// n.intvalue() + 15;
    System.out.println(r);   

// byte[-128,127]
// valueOf()
// 超出127会创建新的地址空间

        Integer num1 = 127;
        Integer num2 = 127;
        // == 比的是地址
        System.out.println(num1 == num2);
        // 值是否相同(equals方法是重写父类的)
        System.out.println(num1.equals(num2));

可变字符串类StringBuffer和StringBuilder

1. 
  String             (线程不安全)          不可变字符串
  StringBuffer       (线程安全,耗费系统资源)  可变字符串
  StringBuilder      (线程不安全)            可变字符串

注意:StringBuffer 与 StringBuilder 的方法完全一致
    二者唯一区别: 线程安全    StringBuffer安全

//  拼接  获取长度   转换成String字符串

//  1.字符串的拼接(String的拼接方法是concat()) StringBuilder对象.append(string);
     // 创建StringBuilder对象
     StringBuilder sb = new StringBuilder();
     // 获取StringBuilder的初始容量  默认16
     sb.capacity();
     // 拼接字符串 (返回的是对象)
     sb.append("wang").append("666").append("哈哈");
     System.out.println(sb);
     输出结果:
     wang666哈哈
//  2.获取字符串的长度  StringBuilder对象.length()
     sb.length();
//  3.转换成String字符串
     sb.toString();

//  插入字符  修改单字符

//  1.插入字符  StringBuilder对象.insert(int index,String str)
    StringBuilder sb = new StringBuilder();
    sb.append("wangjun");
    sb.insert(4,false).append("哈哈");
    System.out.println(sb);
    输出结果:
    wangfalsejun哈哈
//  2.修改单字符  对象名.setCharAt(index,char)
    sb.setCharAt(9,'y');
    System.out.println(sb);
    输出结果:
    wangfalseyun哈哈

//  删除字符串,删除字符,查找字符

//  1.删除字符串   delete(start-index,end-index)
    StringBuilder sb = new StringBuilder();
    sb.append("wangjun");
    // !!注意:如果 结束坐标 超过 字符串长度,相当于清空字符串
    // sb.delete(0, 12);// 留头不留尾[3,4)
    2.删除字符  delete(index)
    sb.deleteCharAt(3);
    System.out.println(sb);
    输出结果:
    wanjun
    3.获取字符
    sb.charAt(3); // 结果为j

// 反转字符串

// 1.反转字符串  对象名.reverse();
    StringBuilder sb = new StringBuilder();
    System.out.println("请输入字符串:");
    Scanner scanner = new Scanner(System.in);
    String str = scanner.nextLine();
    sb.append(str);
    sb.reverse();
    System.out.println(sb.toString());

// 1.替换字符串  对象名.replace(start-index,end-index,string)
    StringBuilder sb = new StringBuilder();
    sb.append("wangjun");
    sb.replace(4, 7, "long");
    System.out.println(sb);
    输出结果:
    "wanglong"
// 2.字符数组 转 StringBuilder
    char[] array = {'a','b','c','d','e'};
    String str = new String(array);
    // 二次转换,将String转换成StringBuilder
    StringBuilder sb1 = new StringBuilder(str);
    System.out.println(sb1);

        /*
         * * 需求
         * 把int[] array = new int[]{1,2,3,4};
         * 输出上面的 [1, 2, 3, 4]
         * 要求:使用两种拼接方法(String 和 StringBuffer)
         */

        // String
        int[] array = new int[]{1,2,3,4};
        String str = "[";
        for (int i = 0; i < array.length; i++) {
            // 拼接元素
            if (i == array.length - 1) {
                // 最后一位

                str = str + "4]";
                break;
            }
            str = str + array[i] + ",";
        }   
        System.out.println(str);

        // StringBuffer
        int[] array1 = new int[]{1,2,3,4};
        StringBuffer sb = new StringBuffer();
        sb.append("[");
        for (int i = 0; i < array1.length; i++) {
            if (i == array.length - 1) {
                sb.append(array1[i]).append("]");
            }else {
                sb.append(array1[i]).append(",");
            }       
        }
        System.out.println(sb);
    }

集合

1.
  数组的弊端:
  1️⃣长度一旦确定,就不能更改  (要添加新的元素,只能创建新的数组)
  2️⃣只能保存 相同数据类型的元素
  集合(容器)的好处
  1️⃣长度可变
  2️⃣能存储 任意引用类型的元素(存储对象)

2.集合的分类:
 1️⃣单列集合
    接口:Collection(所有单列集合的父接口)    jdk1.2

 2️⃣双列集合

3.单列集合

// 1.创建一个单列集合
        // 创建一个集合 
        // 测试一下ArrayList 重写 Collection中的方法
        // 多态的方式创建
        Collection collection = new ArrayList();
        // 当你向集合中添加 基本数据类型时
        // 系统会进行  自动装箱 
        // 实际上保存到集合中的是 Integer对象

        // 添加方法的返回值 什么时候为false?
        // 不可能返回false

        // 为什么该方法要带返回值(一直true)
        // 因为list可重复,set不可重复,所以设计返回值 适用所有子类
        boolean b1 = collection.add(1);
        boolean b2 = collection.add(2);
        boolean b3 = collection.add(3);
        boolean b4 = collection.add(4);
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);
        System.out.println(b4);
        System.out.println(collection);

//  获取集合的长度
//  判断是否包含某个元素
//  从集合中删除一个元素
//  判断集合 是否为空
//  清空数组
//  集合转数组

        Collection collection = new ArrayList();
        collection.add("a");
        collection.add("b");
        collection.add("c");
        collection.add("d");
        // 获取集合的长度  collection.size()
        System.out.println(collection.size());
        // 判断是否包含某个元素  contains()
        Boolean b1 = collection.contains("c");
        System.out.println(b1);
        // 从集合中删除一个元素  remove()
        Boolean b2 = collection.remove("e");
        System.out.println("是否删除成功:" + b2);
        System.out.println(collection);
        // 判断集合是否为空  isEmpty()
        Boolean b3 = collection.isEmpty();
        System.out.println("集合是否为空:" + b3);
        // 清空集合   clear()
        // collection.clear();
        // System.out.println(collection);
        // 集合 转 数组(利用多态,拓展方法,适合所有数据类型)
        Object[] objects = collection.toArray();
        // 1️⃣循环遍历
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }
        // 2️⃣快速遍历
        for(Object s : objects) {
            System.out.println(s);
        }
        // 3️⃣数组类方法遍历
        System.out.println(Arrays.toString(objects));
    }

        /*
         * 多态形式创建一个集合
         * 添加三个学生对象(学生类省略,成员变量:姓名,年龄)
         * 遍历集合
         * 只打印学生姓名(其他的不打印)
         */
        Collection collection = new ArrayList();
        Student s1 = new Student("张三",16) ;
        Student s2 = new Student("赵四",17) ;
        Student s3 = new Student("王五",18) ;
        collection.add(s1);
        collection.add(s2);
        collection.add(s3);
        // 集合转数组
        // 相当于向上转型
        Object[] objects = collection.toArray();
        // 向下转型
        // Student[] students = (Student[]) objects;
        // ClassCastException 类型转换异常
        // 原因:仅仅是容器的类型转换,容器中的元素类型没有转换
        for (int i = 0; i < objects.length; i++) {
            Student student = (Student) objects[i];
            System.out.println(student.getName());
        }