首页 > 编程语言> 文章详细

Java学习二十

2021-10-11 22:35:27 阅读：142 来源： 互联网

标签：Java String 二十 int objArray objArray2 学习数组 public

今天进行了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,String,二十,int,objArray,objArray2,学习,数组,public
来源： https://www.cnblogs.com/jzz-111jy/p/15395267.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

Java学习二十