数组和集合

Array工具类

Arrays.sort();对数组进行排序：默认升序

Arrays.copyOf(数组名,长度);将数组复制一份。

Arrays.toString（）将数组转换成一个字符串

Arrays.fill(数组，值) 给数组填充默认的值

Arrays.binarySearch(数组,值)在有序的列表下，对数组进行二分查找，返回值为第一个找到的下标

Arrays.deepToString()多维数组转换成字符串

数组

数组是同一类型的多条可重复数据组成的一个集合，他在初始化的时候就确定了长度，如果想要获取数组中的值可以通过数组的下标获取。

//定义数组的时候就给他指定长度
        int[] nums = new int[5];
        //整型数组的默认值为0
        for (int num : nums) {
            System.out.println(num);
        }
        String[] strings = new String[5];

        //字符串数组的默认值为null
        for (String string : strings) {
            System.out.println(string);
        }
        int[] nums1;
        nums1 = new int[10];
        //定义数组时并给他赋值
        int[] nums2 = new int[]{10, 20, 50, 25};
        for (int i : nums2) {
            System.out.println(i);
        }

由于数组是引用类型，所以当把数组对象穿给另一个数组对象的时候，其实就是把数组在栈中的地址传给数组对象，所以当改变任何一个数组对象的值的时候，这两个数组对象都会改变。

int[] nums = {10,15,20,35,20 };
        int[] nums1=nums;
        nums[2]=30;
        System.out.println(nums[2]);//30
        System.out.println(nums1[2]);//30
        System.out.println(Arrays.hashCode(nums));//38341161
        System.out.println(Arrays.hashCode(nums1));//38341161

数组的遍历

//anint是ints数组中的各个元素
for (int anInt : ints) {
    System.out.println(anInt);
}
//通过下表遍历
for (int i = 0; i < ints.length; i++) {
    System.out.println(ints[i]);
}
//通过arrays工具类输出数组
System.out.println(java.util.Arrays.toString(ints));

集合

集合存储同一种引用类型数据的容器，集合没有固定长度，集合中的每个元素都是存在下标的，所以集合中的元素是按照存入的顺序排序的。

add（）添加元素

//插入数据尾部
ints.add(1323);
//按照下表进行插入
ints.add(2,21);
//添加一组数据
ints.addAll(new ArrayList<Integer>());
//在指定位置添加一组数据
        ints.addAll(3,new ArrayList<Integer>());

clear（）；

//清楚集合
ints.clear();

contains();

//集合中是否存在元素
ints.contains(112212)

 //根据下标获取集合中的值
 ints.get(1);
 //获取元素中值的下标
 int i1 = ints.indexOf(1323);
//获取集合中最后一次出现当前元素的下标
 ints.lastIndexOf(2);
 //根据索引移除元素
 ints.remove(1);
 //根据下标修改元素的值
 ints.set(1,2);
 //获取集合中存在多少个元素
 ints.size();
 //对元素中的集合排序，如果是数可以用o1-o2是升序反之倒叙，如果是字符串使用o1.compareTo(o2)是升序
 ints.sort((o1, o2) -> {return o1-o2;});
 //转成集合对象
 ints.toArray();
 //根据下标截取元素
 List<Integer> integers = ints.subList(2, 4);

list集合的遍历

for (Integer anInt :
        ints) {
    System.out.println("每个元素"+anInt);
}
Iterator<Integer> iterator = ints.iterator();
while (iterator.hasNext()) {
    System.out.println("迭代器"+iterator.next());
}
for (int i = 0; i < ints.size(); i++) {
    System.out.println("下标"+ints.get(i));
}
ints.forEach(System.out::println);

HashMap

 //map集合又成为键值对集合他key相当于list集合中下标，value相当于list集中的值，但是他是一组
        //不允许存在重复的key的集合。
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "张三");
        map.put(2, "张三");
        map.put(3, "李四");
        //根据key获取值
        String sql = map.get(1);

        // 判断当前集合是否还有值
        boolean empty = map.isEmpty();

        //获取集合的个数
        map.size();
        //根据键值移除元素
        map.remove(1);
        //获取集合中的所有的值
        //清楚集合
        map.clear();

hashmap遍历

//对map集合的值的遍历
Collection<String> values = map.values();
for (String value : values) {
    System.out.println(values);
}

//获取当前集合中的键，并存入set集合当中iterator()迭代器遍历
Set<Integer> integers = map.keySet();
Iterator<Integer> iterator = integers.iterator();
while (iterator.hasNext()) {
    Integer next = iterator.next();
    System.out.println(next+""+map.get(next));
}

//entrySet遍历
Set<Map.Entry<Integer, String>> entries = map.entrySet();
for (Map.Entry<Integer, String> entry : entries) {
    System.out.println(entry.getKey()+entry.getValue());
}