Day06

最新推荐文章于 2023-02-25 11:19:42 发布
最新推荐文章于 2023-02-25 11:19:42 发布
阅读量56 收藏
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SuperYjjj/article/details/113094942
版权

Java学习

文章目录

数组

  • 数组是相同类型数据的有序集合
  • 数组描述的是相同类型的若干个数据，按照一定的先后顺序排列组合而成
  • 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问他们

数组声明

public class ArrayDem01 {
    public static void main(String[] args) {

        int [] nums;//1.定义

        nums = new int[10];//2.存放10个int类型的数据

         //int[] nums = new int [10];

        //3.给元素赋值

        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        nums[5] = 6;
        nums[6] = 7;
        nums[7] = 8;
        nums[8] = 9;
        nums[9] = 10;
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        System.out.println(sum);
    }
}

数组三种初始化方式

public class ArrayDem02 {
    public static void main(String[] args) {
        //静态初始化：创建 + 赋值
        int[] a = {1,2,3,4,5};
        System.out.println(a[0]);

        //动态初始化:包含默认初始化,即未赋值的系统会自动为你赋值0
        int[] b = new int[10];
        b[0] = 10;
        System.out.println(b[0]);
        System.out.println(b[1]);//0

    }
}

数组边界

  • 下标的合法区间：[0,length - 1];
  • ArrayIndexOutOfBoundsException:数组下标越界！

数组小结

  • 数组时相同数据类型（数据类型可以为任意类型）的有序集合
  • 数组也是对象。数组元素相当于对象的成员变量。
  • 数组长度是确定的，不可变的。如果越界会报错。

数组的使用

public class ArrayDem03 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};

        //打印全部数组元素
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }
        System.out.println("===================");
        //计算所有元素的和
        int sum = 0;
        for (int i = 0; i < arrays.length; i++) {
            sum += arrays[i];
        }
        System.out.println("和为："+sum);
        System.out.println("===================");
        //找最大元素
        int max = arrays[0];
        for (int i = 0; i < arrays.length; i++) {
            if(arrays[i] > max){
                max = arrays[i];
            }
        }
        System.out.println("最大值："+max);
    }
}

public class ArrayDem04 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};

        //增强型for循环,省略了下标，不利于操作数组元素
        for (int array : arrays) {
            System.out.println(array);
        }
        System.out.println("======================");
        
        //反转
        int[] reverse = reverse(arrays);
        printArray(reverse);//打印
    }

    //打印数组元素
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+" ");
        }
    }
    
    //反转数组
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];

        //反转操作
        for (int i = 0,j = result.length - 1; i < arrays.length; i++,j--) {
            result[j] = arrays[i];
        }
        return result;
    }
}

多维数组

  • 数组的嵌套可以看作是多维数组

在这里插入图片描述

  • 二维数组遍历
public class ArrayDem05 {
    public static void main(String[] args) {

        //三行两列
        /*
        {   1   ,  2   }    array[0]
        {   2   ,  3   }    array[1]
        {   3   ,  4   }    array[2]

         */
        int[][] array = {{1,2},{2,3},{3,4}};

        printArray(array);
    }

    //打印数组元素
    public static void printArray(int[][] arrays){
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays[i].length; j++) {
                System.out.print(arrays[i][j]+" ");
            }
            System.out.println();
        }
    }
}

Arrays类

toString工具：打印数组
import java.util.Arrays;
public class ArrayDem06 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,6456,2345,56};

        System.out.println(a);//[I@1b6d3586

        //打印数组元素Arrays.toString
        System.out.println(Arrays.toString(a));
        System.out.println("===============================");
        myToString(a);
    }
    public static void myToString(int[] a){
        for (int i = 0; i < a.length; i++) {
            if(i==0){
                System.out.print("[");
            }
            if(i==a.length-1){
                System.out.print(a[i]+"]");
            }else{
                System.out.print(a[i]+", ");
            }
        }
    }
}
sort工具：数组升序
import java.util.Arrays;
public class ArrayDem07 {
    public static void main(String[] args) {
        //排序
        int[] a = {23,45,64,2,678,5,87};

        Arrays.sort(a);//升序
        System.out.println(Arrays.toString(a));
        System.out.println("========================");

        bubbleSort(a);
        System.out.println(Arrays.toString(a));
    }
    //冒泡排序:升序版
//    public static void bubbleSort(int[] array){
//        for (int i = 0; i < array.length-1; i++) {
//            for (int j = 0; j < array.length-1-i; j++) {
//                if(array[j]>array[j+1]){
//                    int tmp = array[j];
//                    array[j] = array[j+1];
//                    array[j+1] = tmp;
//                }
//            }
//        }
//    }
    //冒泡排序:优化升序版
    public static void bubbleSort(int[] array){
        boolean flag = false;//通过flag标识位减少没有意义的比较
        for (int i = 0; i < array.length-1; i++) {
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j]>array[j+1]){
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    flag = true;
                }
            }
            if(flag == false){
                break;
            }
        }
    }
fill工具：数组填充
import java.util.Arrays;
public class ArrayDem08 {
    public static void main(String[] args) {
        int[] a = {34,677,345,2,45};

        //数组填充
//        Arrays.fill(a,0);
//        System.out.println(Arrays.toString(a));

        //指定填充
//        Arrays.fill(a,2,4,0);//下边2到4变为0
//        System.out.println(Arrays.toString(a));
    }
}

稀疏数组

  • 棋盘
public class ArrayDem09 {
    public static void main(String[] args) {
        //1、创建一个二维数组11*11   0：没有棋子  1：黑棋    2：白棋
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;

        System.out.println("原始数组：");
        for (int[] ints : array) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        //转换为稀疏数组保存
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if(array[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值个数："+sum);

        //2.创建一个稀疏数组
        int[][] array2 = new int[sum+1][3];

        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        //遍历二维数组，将非零的值，存放稀疏数组中
        int count = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if(array[i][j]!=0){
                    count++;
                    array2[count][0] = i;//行
                    array2[count][1] = j;//列
                    array2[count][2] = array[i][j];//有效值
                }
            }
        }
        //输出稀疏数组
        System.out.println("稀疏数组：");
        System.out.println("行\t"+"列\t"+"有效值\t");
        for (int i = 0; i < array2.length; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(array2[i][j]+"\t");
            }
            System.out.println();
        }
        System.out.println("===========================");
        System.out.println("还原");
        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];

        //2.给元素还原它的值
        for(int i = 1;i< array2.length;i++){
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
            //array3[行][列] = 有效值
            //即把有效值按照有效值坐标的位置赋值给新数组，其余系统默认为0
        }
        System.out.println("还原数组：");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}

面向对象

面向过程&面向对象

  • 面向过程思想(线性思维)

    • 步骤清晰简单，第一部做什么，第二部做什么
    • 面向过程适合处理一些较为简单的问题。

  • 面向对象思想

    • 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
    • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！

  • 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

什么是面向对象

  • 面向对象编程（Object-Oriented Programming,OOP)

  • 面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。

  • 属性加方法就会变成一个类

  • 抽象

  • 三大特性：

    • 封装
    • 继承
    • 多态

回顾

方法

  • 静态方法
public class Dem01 {
	public static void main(String[] args) {
    //静态方法：直接通过类名去调用方法
    Student.say();
	}
}
--------------------------------------------------------
public class Student {
    public static void say(){
        System.out.println("学生讲话");
    }
}
  • 非静态方法
public class Dem01 {
    public static void main(String[] args) {
    //非静态方法：先创建一个对象，通过对象调用方法
    Student student = new Student();
    student.say();
    }
}
--------------------------------------------------------
public class Student {
    public void say(){
        System.out.println("学生讲话");
    }
}
  • 有static和没static的区别是static是和类一起加载的，类创建出来的时候static就存在了。没有static的，只有在实例化对象后才会存在。

值传递和引用传递

//值传递和引用传递
public class Dem02 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);//null

        int a = 20;
        change(a);
        System.out.println(a);//值传递,20

        setName(person);//应用传递，yjj
        System.out.println(person.name);
    }
    public static void change(int a){
        a = 10;
    }
    public static void setName(Person person){
        //person是一个对象：指向的---> Person person = new Person();
        //这是一个具体的人，可以改变属性！
        person.name = "yjj";
    }
}
//Person类，属性:name
class Person {
    String name;
}
       int a = 20;
        change(a);
        System.out.println(a);//值传递,20

        setName(person);//应用传递，yjj
        System.out.println(person.name);
    }
    public static void change(int a){
        a = 10;
    }
    public static void setName(Person person){
        //person是一个对象：指向的---> Person person = new Person();
        //这是一个具体的人，可以改变属性！
        person.name = "yjj";
    }
}
SuperYjjj
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Python-Numpy学习之【ndim、shape、dtype函数的区别】
小白摸索之路
01-25 3987
刚开始学习numpy，对ndim、shape还有dtype这几个函数的含义有些混淆，所以简单记录下。 ndim函数：返回一个数字，确定数组的维度 备注：个人小技巧（不知道准不准），从列表转数组时，确定数组的维度的话可以看一开始中括号的个数，几个中括号就是几维。 shape函数：返回一个元组，确定各个维度的元素个数 对于arr11：它是一个一维数组，返回的（4，）代表一维里面有四个元素 对于arr22：它是一个二维数组，返回的（2，3）中 2 代表的是行（row），代表一维里面有2个元素，3代表的是列（c
传递参数格式为form-data与json的区别，以及ajax、axios、fetch请求的方式
qq_35046569的博客
09-18 2万+
标题前端请求后台接口时，传递参数格式为form-data与json的区别 一、form-data格式 请求头： 1.application/x-www-form-urlencoded 表单格式提交数据，通过form标签的action属性，如果不设置 enctype 属性，那么最终就会以 application/x-www-form-urlencoded 方式提交数据 html: <form id="myform" onsubmit="return false;"> 用户名：<i
寻找两个正序数组的中位数
wulila的博客
04-28 2336
寻找两个正序数组的中位数 时隔许久，我又杀回来了。 题目：给定两个大小分别为m和n的正序（从小到大）数组nums1和nums2。请你找出并返回这两个正序数组的中位数。 要求算法的时间复杂度为O(log(m+n))。 示例1： 输入：nums1 = [1,3], nums2 = [2] 输出：2.00000 解释：合并数组 = [1,2,3] ，中位数 2 示例2： 输入：nums1 = [1,2], nums2 = [3,4] 输出：2.50000 解释：合并数组 = [1,2,3,4] ，中位数 (
指针与数组的联系与区别【一万六千字超详解】
malloc不出对象的博客
12-25 6192
本文主要讲解的是指针与数组之间的联系与区别
cjson构建_cjson创建数组
weixin_39950083的博客
12-20 2432
这里介绍如何使用cjson，创建一个含数组的json字串。例如下面的形式：{"UnixSocket":[{"id":0,"value":10.0}]}干脆一些，直接上代码：int Jsondata_Create_Json(char *pBuf, int id, int type, int value, float fvalue){cJSON *root;cJSON *Array;cJSON *ob...
学习JavaEE的day06
02-28
在“学习JavaEE的day06”这个主题中，我们主要关注的是Java企业级应用开发的相关内容。JavaEE，全称Java Platform, Enterprise Edition，是一个用于构建分布式、多层的企业级应用程序的平台。它提供了丰富的API和...
Hive进阶Day06
最新发布
04-15
Hive进阶Day06
Day06-07
03-14
在"Day06-07"的学习中，你可能还会接触到表格（）、列表（、和）、表格（）、输入元素（）等，这些都是创建交互式网页的关键组件。例如，用于收集用户数据，可以设置不同类型的输入框，如文本（type="text"）、密码...
LeetCode:寻找两个正序数组的中位数----多种解题方式
小鱼干儿的博客
10-20 2206
使用多种的经典的算法思想解决 LeetCode:寻找两个正序数组的中位数
数组和指针的区别与联系（详细）
热门推荐
cherrydreamsover的博客
08-16 13万+
指针和数组的区别： 1.概念： 2.存储方式、初始化（指针数组、数组指针）、存储内容（求sizeof） 3.赋值 6.传参（函数指针、函数指针数组、函数指针数组的指针、野指针） 一、概念 数组：数组是用于储存多个相同类型数据的集合。 指针：指针相当于一个变量，但是它和不同变量不一样，它存放的是其它变量在内存中的地址。 二、赋值、存储方式、求sizeof、初始化等 1.赋...
浅谈数组与指针的区别
DYDlove的博客
02-29 602
定义; 数组：数组是用于储存多个相同类型数据的集合。 指针：指针是一个变量，但是它和普通变量不一样，它存放的是其它变量在内存中的地址。 两者区别如下： 1.赋值 数组：只能一个一个元素的赋值或拷贝 。除了在初始化数组时可以把所有的元素都初始化一个值。这个可以忽略 指针：指针变量可以相互赋值。 比如定义了int a[5]和int b[5]后，不能使a = b，是错误的。因为在定义数组的时候，一旦分配...
matlab处理数据，提示“提示位置1处的索引超出数组边界。不能超出1”，这该怎么处理呢
weixin_62899120的博客
02-25 4776
matlab处理数据，提示“提示位置1处的索引超出数组边界。不能超出1”，这该怎么处理呢
Java - 重要集合：PriorityQueue
kaiwawah的博客
10-12 404
Java集合框架中提供了PriorityQueue和PriorityBlockingQueue两种类型的优先级队列，PriorityQueue是线程不安全的，PriorityBlockingQueue是线程安全的通过观察源码：使用必须导包！堆有很多方法的，接下来我们将学习堆！PriorityQueue中放置的元素必须要能够比较大小，，否则会抛出ClassCastException异常，否则会抛出NullPointerException没有容量限制，可以插入任意多个元素，其内部可以自动扩容。
list取第一个 vue_vue 循环加载数据并获取第一条记录的方法
weixin_29621655的博客
02-07 4902
最近使用elment ui和vue.js，遇到需要像c:foreach类似的效果，就找了vue的API：https://cn.vuejs.org/v2/guide/list.html#v-for-with-v-ifelement ui：http://element.eleme.io/#/zh-CN/component/input用法：v-if="index==0" v-bind:month="mo...
python ndim函数_Python列表函数ndim和大小
weixin_28911533的博客
02-09 1494
我停留在这一点上的代码，其中代码是指打印使用NDIM和大小列表的大小和尺寸。我收到一个错误“list object has no attribute ndim。”`进口OSimport skimageimport pdbfrom skimage import dataROOT_PATH = "/tmp/"train_data_directory =os.path.join(ROOT_PATH,\m...
python-Numpy学习之(一)ndim、shape、dtype、astype的用法
a1809032425的博客
09-02 6万+
python-Numpy学习之(一)ndim、shape、dtype、astype的用法 参考网址：https://blog.csdn.net/Da_wan/article/details/80518725 本文介绍numpy数组中这四个方法的区别ndim、shape、dtype、astype。 1.ndim ndim返回的是数组的维度，返回的只有一个数，该数即表示数组的维度。 2....
用PriorityQueue解决选择最小的K个数问题
x_i_y_u_e的专栏
03-19 5330
Java 中的PriorityQueue是一个基于优先级堆的无界优先级队列。优先级队列的元素按照其自然顺序进行排序，或者根据构造队列时提供的 Comparator 进行排序，具体取决于所使用的构造方法。优先级队列不允许使用 null 元素。依靠自然顺序的优先级队列还不允许插入不可比较的对象（这样做可能导致 ClassCastException）。 此队列的头是按指定排序方式确定的最小元素。如果多
JavaSE就业班Day06：日期时间与正则表达式作业
"JavaSE--day06的每日作业涵盖了Date类、DateFormat、Calendar、Math、System、包装类、正则表达式等多个核心知识点，旨在提升学员对Java基础的掌握和应用能力。" 1. **Date类** - Date类在Java中用于表示特定的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值