Java学习二十

2021/10/11 22:44:06

本文主要是介绍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、

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

2、

 1 package Java数组;
 2 
 3 import java.util.Arrays;
 4 import java.util.Collections;
 5 
 6 /*
 7 数组获取最大和最小值
 8 通过 Collections 类的 Collections.max() 和 Collections.min() 方法来查找数组中的最大和最小值
 9  */
10 public class _6arraymain {
11     public static void main(String[] args) {
12         Integer[] numbers = { 8, 2, 7, 1, 4, 9, 5};
13         int max=(int) Collections.max(Arrays.asList(numbers));
14         int min=(int)Collections.min(Arrays.asList(numbers));
15         System.out.println("最大值:"+max);
16         System.out.println("最小值:"+min);
17     }
18     /*
19     collections.max和collections.min方法在util包中,分别返回最大值和最小值
20     asList(),该方法是将数组转化成List集合的方法。
21         注意:
22 
23 (1)该方法适用于对象型数据的数组(String、Integer...)
24 (2)该方法不建议使用于基本数据类型的数组(byte,short,int,long,float,double,boolean)
25 (3)该方法将数组与List列表链接起来:当更新其一个时,另一个自动更新
26 (4)不支持add()、remove()、clear()等方法
27      */
28 }

3、

 1 package Java数组;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Arrays;
 5 import java.util.List;
 6 
 7 /*
 8 数组合并
 9 通过 List 类的 Arrays.toString () 方法和 List 类的 list.Addall(array1.asList(array2) 方法将两个数组合并为一个数组
10  */
11 public class _7arrayMerge {
12     public static void main(String[] args) {
13         String a[] = { "A", "E", "I" };
14         String b[] = { "O", "U" };
15         List list=new ArrayList(Arrays.asList(a));
16         list.addAll(Arrays.asList(b));
17         Object[] c=list.toArray();
18         System.out.println(Arrays.toString(c));
19     }
20     /*
21     asList()将数组转化为list集合
22     addAll()添加所有元素到列表中
23      */
24 }

4、

 1 package Java数组;
 2 
 3 import java.util.Arrays;
 4 
 5 /*
 6 数组填充
 7 通过 Java Util 类的 Arrays.fill(arrayname,value) 方法和Arrays.fill(arrayname ,starting index ,ending index ,value) 方法向数组中填充元素
 8  */
 9 public class _8arrayFill {
10     public static void main(String[] args) {
11         int array[]=new int[6];
12         Arrays.fill(array,100);
13         //循环遍历
14         for(int i=0,n=array.length;i<n;i++){
15             System.out.println(array[i]);
16         }
17         System.out.println();
18         Arrays.fill(array,3,6,50);
19         for(int i=0,n=array.length;i<n;i++){
20             System.out.println(array[i]);
21         }
22     }
23     /*
24     Fill    public static void fill(Object[] a,  int fromIndex,  int toIndex,   Object val)将指定的 Object 引用分配给指定 Object 数组指定范围中的每个元素。填充的范围从索引 fromIndex(包括)一直到索引 toIndex(不包括)。
25     Arrays.fill( a1, value );填充a1数组中的每个元素都是value
26      */
27 }

5、

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

6、

 1 package Java数组;
 2 /*
 3 查找数组中的重复元素
 4 在 java 中找到重复的元素
 5  */
 6 public class _10arrayrepeat {
 7     public static void main(String[] args) {
 8         int[] my_array = {1, 2, 5, 5, 6, 6, 7, 2, 9, 2};
 9         findRepeat(my_array);
10     }
11 
12     //定义方法
13     public static void findRepeat(int[] a){
14         int count=0;
15         for(int j=0;j<a.length;j++){
16             for(int k=j+1;k<a.length;k++){
17                 if(a[j]==a[k]){
18                     count++;
19                 }
20             }
21             if(count==1)
22                 System.out.println("重复元素:"+a[j]);
23             count=0;
24         }
25     }
26 
27 }

7、

 1 package Java数组;
 2 
 3 import java.util.Arrays;
 4 
 5 /*
 6 删除数组元素
 7 Java 的数组是固定长度的,无法直接删除,我们可以通过创建一个新数组,把原始数组中要保留的元素放到新数组中即可
 8  */
 9 public class _11arrayDelete {
10     public static void main(String[] args) {
11         int[] oldarray = new int[] {3, 4, 5, 6, 7};// 原始数组
12         int num = 2;   // 删除索引为 2 的元素,即删除第三个元素 5
13         int[] newArray = new int[oldarray.length-1];// 新数组,长度为原始数组减去 1
14         for(int i=0;i< newArray.length;i++){
15             //判断元素是否越界
16             if(num<0||num>= oldarray.length){
17                 throw new RuntimeException("元素越界...");
18             }
19             if(i<num){
20                 newArray[i]=oldarray[i];
21             }else
22             {
23                 newArray[i]=oldarray[i+1];
24             }
25         }
26         System.out.println(Arrays.toString(oldarray));
27         oldarray = newArray;
28         System.out.println(Arrays.toString(oldarray));
29     }
30 }

8、

 1 package Java数组;
 2 
 3 import java.util.ArrayList;
 4 
 5 /*
 6 数组差集
 7 使用 removeAll () 方法来计算两个数组的差集
 8  */
 9 public class _12ArrayDifferenceSet {
10     public static void main(String[] args) {
11         ArrayList objArray = new ArrayList();
12         ArrayList objArray2 = new ArrayList();
13         objArray2.add(0,"common1");
14         objArray2.add(1,"common2");
15         objArray2.add(2,"notcommon");
16         objArray2.add(3,"notcommon1");
17         objArray.add(0,"common1");
18         objArray.add(1,"common2");
19         objArray.add(2,"notcommon2");
20         System.out.println("array1 的元素" +objArray);
21         System.out.println("array2 的元素" +objArray2);
22         objArray.removeAll(objArray2);//去除重复元素
23         System.out.println("array1 与 array2 数组差集为:"+objArray);
24     }
25 }

9、

 1 package Java数组;
 2 
 3 import java.util.ArrayList;
 4 
 5 /*
 6 数组交集
 7 使用 retainAll () 方法来计算两个数组的交集
 8  */
 9 public class _13ArrayIntersection {
10     public static void main(String[] args) {
11         ArrayList objArray = new ArrayList();
12         ArrayList objArray2 = new ArrayList();
13         objArray2.add(0,"common1");
14         objArray2.add(1,"common2");
15         objArray2.add(2,"notcommon");
16         objArray2.add(3,"notcommon1");
17         objArray.add(0,"common1");
18         objArray.add(1,"common2");
19         objArray.add(2,"notcommon2");
20         System.out.println("array1 数组元素:"+objArray);
21         System.out.println("array2 数组元素:"+objArray2);
22         objArray.retainAll(objArray2);
23         System.out.println("array2 & array1 数组交集为:"+objArray);
24     }
25     /*
26     retainAll的返回值并不能用于判断两个集合是否存在交集,只能用于判断集合大小是否发生改变; 应该通过集合的大小判断两个集合是否有交集。
27      */
28 }

10、

 1 package Java数组;
 2 
 3 import java.util.ArrayList;
 4 
 5 /*
 6 在数组中查找指定元素
 7 使用 contains () 方法来查找数组中的指定元素
 8  */
 9 public class _14arraySearcg {
10     public static void main(String[] args) {
11         ArrayList<String> objArray = new ArrayList<String>();
12         ArrayList<String> objArray2 = new ArrayList<String>();
13         objArray2.add(0,"common1");
14         objArray2.add(1,"common2");
15         objArray2.add(2,"notcommon");
16         objArray2.add(3,"notcommon1");
17         objArray.add(0,"common1");
18         objArray.add(1,"common2");
19         System.out.println("objArray 的数组元素:"+objArray);
20         System.out.println("objArray2 的数组元素:"+objArray2);
21         System.out.println("objArray 是否包含字符串common2? : "
22                 +objArray.contains("common2"));
23         System.out.println("objArray2 是否包含数组 objArray? :"
24                 +objArray2.contains(objArray) );
25     }
26     /*
27     contains(),该方法是判断字符串中是否有子字符串。如果有则返回true,如果没有则返回false
28      */
29 }

11、

 1 package Java数组;
 2 
 3 import java.util.Arrays;
 4 
 5 /*
 6 判断数组是否相等
 7 使用 equals ()方法来判断数组是否相等
 8  */
 9 public class _15arrayEqual {
10     public static void main(String[] args) {
11         int[] ary = {1,2,3,4,5,6};
12         int[] ary1 = {1,2,3,4,5,6};
13         int[] ary2 = {1,2,3,4};
14         System.out.println("数组 ary 是否与数组 ary1相等? :"
15                 +Arrays.equals(ary, ary1));
16         System.out.println("数组 ary 是否与数组 ary2相等? :"
17                 +Arrays.equals(ary, ary2));
18     }
19     /*
20     equal()方法用来比较数据是否相等,相等返回true,不同返回false.通常判断的时候使用
21      */
22 }

12、

 1 package Java数组;
 2 
 3 import java.util.Collection;
 4 import java.util.HashSet;
 5 import java.util.Iterator;
 6 import java.util.Set;
 7 
 8 /*
 9 数组并集
10 使用 union ()方法来计算两个数组的并集
11  */
12 public class _16ArrayUnion {
13     public static void main(String[] args) {
14         String[] arr1 = { "1", "2", "3" };
15         String[] arr2 = { "4", "5", "6" };
16         String[] result_union = union(arr1, arr2);
17         System.out.println("并集的结果如下:");
18 
19         for (String str : result_union) {
20             System.out.print(str+" ");
21         }
22     }
23 
24     //定义方法求两个字符串的并集,set集合具有唯一性
25     public static String[] union(String[] arr1,String[] arr2){
26         Set<String> set=new HashSet<>();
27         for(String str:arr1){
28             set.add(str);
29         }
30         for(String str:arr2){
31             set.add(str);
32         }
33         String[] result={ };
34         return set.toArray(result);
35     }
36 }

 

       



这篇关于Java学习二十的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程