Java学习二十

今天进行了mysql数据库DQL剩余部分的学习，并进行了Java数组实例练习。

一、DQL：查询语句

　　　　1、排序查询   语法：order by 子句

　　　　　　（1）order by 排序字段1 排序方式1，...;   select * from stu order by math;  将学生按数学成绩排序

　　　　　　（2）排序方式  ASC:升序；DESC：降序。

　　　　　　注：多个排序条件，前边的条件值相同时才会判断下一个条件。

　　　　2、聚合函数：将一列数据作为一个整体，进行纵向运算

　　　　　　（1）count：计算个数   select count(name) from stu; 根据名字（name）计算学生个数

　　　　　　（2）max：selet max(math) from stu;查询数学成绩最高的学生

　　　　　　（3）min：select min(math) from stu; 查询数学成绩最低的学生

　　　　　　（4）sum: select sum(math) from stu;查询数学成绩的和

　　　　　　（5）avg： select avg(math) from stu;求学生数学成绩的平均值

　　　　　　注：聚合函数不对数据为null的数据计数，解决方法：①将null转为0；②使用ifnull()函数替换

　　　　3、分组查询  group by 字段； select stu group by sex;

　　　　　　注：（1）分组之后查询字段:分组字段，聚合函数

　　　　　　　　　　select sex,avg(math) from stu group by sex;

　　　　　　　　（2）where和having区别

　　　　　　　　　　①where在分组前限定，不满足条件则不参与分组，having分组之后限定，如果不满足条件则不会被查询出来

　　　　　　　　　　②where后不可以跟聚合函数，having可以进行聚合函数判断

　　　　4、分页查询

　　　　　　（1）limit 开始的索引，每页记录的条数； 我们平常使用的百度搜索引擎便是分页查询

　　　　　　　　selecct * from stu limit 0,3; 将学生信息按每页三条记录展示

　　　　　　（2）开始的索引=（当前页码-1）*每页记录的条数；

　　　　　　　　注：分页操作是一个“方言”，只能在mysql中使用。

二、数组实例练习

1、

package Java数组;
//使用循环进行输出
public class _5arraybianli {
    public static void main(String[] args) {
        String[] runoobs = new String[3];
        runoobs[0] = "菜鸟教程";
        runoobs[1] = "菜鸟工具";
        runoobs[2] = "菜鸟笔记";
        for (int i = 0; i < runoobs.length; i++){
            System.out.println(runoobs[i]);
        }
    }
}

2、

package Java数组;

import java.util.Arrays;
import java.util.Collections;

/*
数组获取最大和最小值
通过 Collections 类的 Collections.max() 和 Collections.min() 方法来查找数组中的最大和最小值
 */
public class _6arraymain {
    public static void main(String[] args) {
        Integer[] numbers = { 8, 2, 7, 1, 4, 9, 5};
        int max=(int) Collections.max(Arrays.asList(numbers));
        int min=(int)Collections.min(Arrays.asList(numbers));
        System.out.println("最大值："+max);
        System.out.println("最小值："+min);
    }
    /*
    collections.max和collections.min方法在util包中，分别返回最大值和最小值
    asList(),该方法是将数组转化成List集合的方法。
        注意：

（1）该方法适用于对象型数据的数组（String、Integer...）
（2）该方法不建议使用于基本数据类型的数组（byte,short,int,long,float,double,boolean）
（3）该方法将数组与List列表链接起来：当更新其一个时，另一个自动更新
（4）不支持add()、remove()、clear()等方法
     */
}

3、

package Java数组;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/*
数组合并
通过 List 类的 Arrays.toString () 方法和 List 类的 list.Addall(array1.asList(array2) 方法将两个数组合并为一个数组
 */
public class _7arrayMerge {
    public static void main(String[] args) {
        String a[] = { "A", "E", "I" };
        String b[] = { "O", "U" };
        List list=new ArrayList(Arrays.asList(a));
        list.addAll(Arrays.asList(b));
        Object[] c=list.toArray();
        System.out.println(Arrays.toString(c));
    }
    /*
    asList()将数组转化为list集合
    addAll（）添加所有元素到列表中
     */
}

4、

package Java数组;

import java.util.Arrays;

/*
数组填充
通过 Java Util 类的 Arrays.fill(arrayname,value) 方法和Arrays.fill(arrayname ,starting index ,ending index ,value) 方法向数组中填充元素
 */
public class _8arrayFill {
    public static void main(String[] args) {
        int array[]=new int[6];
        Arrays.fill(array,100);
        //循环遍历
        for(int i=0,n=array.length;i<n;i++){
            System.out.println(array[i]);
        }
        System.out.println();
        Arrays.fill(array,3,6,50);
        for(int i=0,n=array.length;i<n;i++){
            System.out.println(array[i]);
        }
    }
    /*
    Fill    public static void fill(Object[] a,  int fromIndex,  int toIndex,   Object val)将指定的 Object 引用分配给指定 Object 数组指定范围中的每个元素。填充的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。
    Arrays.fill（ a1, value ）;填充a1数组中的每个元素都是value
     */
}

5、

package Java数组;
/*
数组扩容
在数组初始化后对数组进行扩容
 */
public class _9ArrayExpansion {
    public static void main(String[] args) {
        String[] names = new String[] { "A", "B", "C" };
        String[] extended = new String[5];
        extended[3]="D";
        extended[4]="E";
        System.arraycopy(names,0,extended,0,names.length);
        //增强for遍历
        for(String str:extended){
            System.out.println(str);
        }
    }
    /*
    public static native void arraycopy(Object src,  int  srcPos,Object dest, int destPos,int length);
 *  第一个参数：src  原数组对象
 *  第二个参数：srcPos  从原数组的[srcPos]下标开始复制
 *  第三个参数：dest  目标数组对象
 *  第四个参数：destPos  目标数组从[destPos]开始存储
 *  第五个参数：length  表示从原数组复制几个元素
 *  说明：如果src和dest是同一个数组的话，那么就会实现数组的元素的移动效果
 *
 *  srcPos > destPos ：往左移动      一般用于删除
 *  srcPos < destPos ：往右移动      一般用于插入
         */
}

6、

package Java数组;
/*
查找数组中的重复元素
在 java 中找到重复的元素
 */
public class _10arrayrepeat {
    public static void main(String[] args) {
        int[] my_array = {1, 2, 5, 5, 6, 6, 7, 2, 9, 2};
        findRepeat(my_array);
    }

    //定义方法
    public static void findRepeat(int[] a){
        int count=0;
        for(int j=0;j<a.length;j++){
            for(int k=j+1;k<a.length;k++){
                if(a[j]==a[k]){
                    count++;
                }
            }
            if(count==1)
                System.out.println("重复元素："+a[j]);
            count=0;
        }
    }

}

7、

package Java数组;

import java.util.Arrays;

/*
删除数组元素
Java 的数组是固定长度的，无法直接删除，我们可以通过创建一个新数组，把原始数组中要保留的元素放到新数组中即可
 */
public class _11arrayDelete {
    public static void main(String[] args) {
        int[] oldarray = new int[] {3, 4, 5, 6, 7};// 原始数组
        int num = 2;   // 删除索引为 2 的元素，即删除第三个元素 5
        int[] newArray = new int[oldarray.length-1];// 新数组，长度为原始数组减去 1
        for(int i=0;i< newArray.length;i++){
            //判断元素是否越界
            if(num<0||num>= oldarray.length){
                throw new RuntimeException("元素越界...");
            }
            if(i<num){
                newArray[i]=oldarray[i];
            }else
            {
                newArray[i]=oldarray[i+1];
            }
        }
        System.out.println(Arrays.toString(oldarray));
        oldarray = newArray;
        System.out.println(Arrays.toString(oldarray));
    }
}

8、

package Java数组;

import java.util.ArrayList;

/*
数组差集
使用 removeAll () 方法来计算两个数组的差集
 */
public class _12ArrayDifferenceSet {
    public static void main(String[] args) {
        ArrayList objArray = new ArrayList();
        ArrayList objArray2 = new ArrayList();
        objArray2.add(0,"common1");
        objArray2.add(1,"common2");
        objArray2.add(2,"notcommon");
        objArray2.add(3,"notcommon1");
        objArray.add(0,"common1");
        objArray.add(1,"common2");
        objArray.add(2,"notcommon2");
        System.out.println("array1 的元素" +objArray);
        System.out.println("array2 的元素" +objArray2);
        objArray.removeAll(objArray2);//去除重复元素
        System.out.println("array1 与 array2 数组差集为："+objArray);
    }
}

9、

package Java数组;

import java.util.ArrayList;

/*
数组交集
使用 retainAll () 方法来计算两个数组的交集
 */
public class _13ArrayIntersection {
    public static void main(String[] args) {
        ArrayList objArray = new ArrayList();
        ArrayList objArray2 = new ArrayList();
        objArray2.add(0,"common1");
        objArray2.add(1,"common2");
        objArray2.add(2,"notcommon");
        objArray2.add(3,"notcommon1");
        objArray.add(0,"common1");
        objArray.add(1,"common2");
        objArray.add(2,"notcommon2");
        System.out.println("array1 数组元素："+objArray);
        System.out.println("array2 数组元素："+objArray2);
        objArray.retainAll(objArray2);
        System.out.println("array2 & array1 数组交集为："+objArray);
    }
    /*
    retainAll的返回值并不能用于判断两个集合是否存在交集，只能用于判断集合大小是否发生改变； 应该通过集合的大小判断两个集合是否有交集。
     */
}

10、

package Java数组;

import java.util.ArrayList;

/*
在数组中查找指定元素
使用 contains () 方法来查找数组中的指定元素
 */
public class _14arraySearcg {
    public static void main(String[] args) {
        ArrayList<String> objArray = new ArrayList<String>();
        ArrayList<String> objArray2 = new ArrayList<String>();
        objArray2.add(0,"common1");
        objArray2.add(1,"common2");
        objArray2.add(2,"notcommon");
        objArray2.add(3,"notcommon1");
        objArray.add(0,"common1");
        objArray.add(1,"common2");
        System.out.println("objArray 的数组元素："+objArray);
        System.out.println("objArray2 的数组元素："+objArray2);
        System.out.println("objArray 是否包含字符串common2? ： "
                +objArray.contains("common2"));
        System.out.println("objArray2 是否包含数组 objArray? ："
                +objArray2.contains(objArray) );
    }
    /*
    contains（）,该方法是判断字符串中是否有子字符串。如果有则返回true，如果没有则返回false
     */
}

11、

package Java数组;

import java.util.Arrays;

/*
判断数组是否相等
使用 equals ()方法来判断数组是否相等
 */
public class _15arrayEqual {
    public static void main(String[] args) {
        int[] ary = {1,2,3,4,5,6};
        int[] ary1 = {1,2,3,4,5,6};
        int[] ary2 = {1,2,3,4};
        System.out.println("数组 ary 是否与数组 ary1相等? ："
                +Arrays.equals(ary, ary1));
        System.out.println("数组 ary 是否与数组 ary2相等? ："
                +Arrays.equals(ary, ary2));
    }
    /*
    equal()方法用来比较数据是否相等，相等返回true,不同返回false.通常判断的时候使用
     */
}

12、

package Java数组;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

/*
数组并集
使用 union ()方法来计算两个数组的并集
 */
public class _16ArrayUnion {
    public static void main(String[] args) {
        String[] arr1 = { "1", "2", "3" };
        String[] arr2 = { "4", "5", "6" };
        String[] result_union = union(arr1, arr2);
        System.out.println("并集的结果如下：");

        for (String str : result_union) {
            System.out.print(str+" ");
        }
    }

    //定义方法求两个字符串的并集，set集合具有唯一性
    public static String[] union(String[] arr1,String[] arr2){
        Set<String> set=new HashSet<>();
        for(String str:arr1){
            set.add(str);
        }
        for(String str:arr2){
            set.add(str);
        }
        String[] result={ };
        return set.toArray(result);
    }
}