ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 编程语言> 文章详细

大数据基础：JavaSE_day06

2021-03-26 20:03:51  阅读：107  来源： 互联网

标签：arr String int day06 System JavaSE 数据 public out 


                                                            优秀是一种习惯

Java 语言背景

  1. JavaSE 其他两个版本的基础 用来做桌面的开发 主要为今后从事大数据开发 打基础
  2. JavaME 嵌入式消费类型的电子设备
  3. JavaEE web开发 做web页面和后台功能实现

Java语言跨平台的原理

  1. Java语言 一次编译到处运行

  2. Java开发

    1. 编写Java

      1. JRE Java运行环境 包括JVM和核心类库
      2. JVM 虚拟机 本身不可以跨平台 允许跨平台的是Java程序

    2. 编译Java

      1. .java文件 属于 源文件 ，无法被JVM所识别执行的
      2. 使用Java提供的JDK中的翻译工具

    3. 运行Java

      JDK 是Java语言你的软件开发工具包，包含代码的编译工具和运行工具

JVM，JRE，JDK关系

JDK =JRE ＋开发工具

JRE＝JVM＋核心类库

DOS命令

为了使用Javac和Java命令

  1. 盘符: 切换到某盘
  2. cd 进入
  3. dir 显示当前目录下所有文件
  4. cd / 进入根目录
  5. exit 退出

HelloWorld详解

public class HelloWrold{
    public static void main(String[] args){
        System.out.println("helloworld");
    }
}
  1. public 限定类名和文件名保持一致 记
  2. class 定义一个类
  3. hellowrld 类型
  4. main 主方法 JVM 只会调用main方法 Java程序的入口
  5. System.out.println(""); 输出语句

编程中可能会出现的问题

  1. bug 程序中的缺陷问题
  2. 单词写错 没区分大小写
  3. 使用中文字符
  4. 类名和文件名不一致

注释

给程序员看的 并不会给JVM看

  1. 单行注释 //
  2. 多行注释 /* */
  3. 文档注释 /** */

关键字

Java赋予了特殊含义的单词

  1. 全小写 字母
  2. 在一些代码编辑工具中会有颜色标记

常量

作用:在代码运行期间 其值不会发生变化的数据

  1. 整数常量

    例如:1,2,3,11,33,212

  2. 小数常量

    例如:1.22,12.13

  3. 字符常量

    例如:‘A’,‘a’,‘1’

  4. 字符串常量

    例如:“黑马”,“abc”

  5. 布尔常量

    例如:true,false

  6. 空常量

    只有一个:null

    不能单独打印

变量

作用:使用变量记录一些经常发生变化的数据

变量是什么:内存中一小块存储区域 这个区域中的值经常发生变化

变量的定义格式: 数据类型 变量名=初始化值;

变量的使用:拿变量名使用 拿变量名获取这个变量对应的值

注意事项:

  1. 变量名不可以重名

  2. 一行上可以定义同类型的数据

    例如:int a,b,c;

    ​ int a=11,b=22,c=33;

  3. 变量使用前,必须要有一个初始化

  4. 定义float与long 对应初始化值后面加上F/f和L/l;

  5. 变量的作用范围 变量所在的大括号中

数据类型

分为基本数据类型和引用数据类型。

基本数据类型 四类八种：

  1. 整数类型: byte short int long
  2. 浮点类型: float doublee
  3. 布尔类型: boolean
  4. 字符类型: char

引用数据类型：

  1. 数组
  2. String
  3. 接口interface
  4. 类
整数类型:
         字节Byte       范围
byte        1B          -128~127
short       2B          -2^15~2^15-1
int         4B          -2^31~2^31-1   默认
long        8B       
浮点类型   
float       4B
double      8B                         默认
字符
char        2B
布尔类型             
boolean     1B
             
定义float类型变量时 后面必须加上F或f;
定义double类型变量时  后面可以不加D或d;
定义long类型变量时   后面必须加上L或l;

int类型和float类型所占都是4个字符,那种数据类型所储存的数据大呢?
    float在数据结构中存在的方式是用指数表示的 采用科学技术法
    所以float表示的数据范围要比int大

数据类型转化

自动转换/隐式转换

要求:

  1. 将数据范围小的 赋予一个数据范围大的

  2. 一个小的和一个大的计算时 小的提升为大的 然后计算

    byte–>short–>int–>long–>float–>double

    char–>int–>long–>float–>double

    byte、short、char 参与计算时 会提升为int 记

    例如:将数据范围小的 赋予一个数据范围大的
int a=222;
long b=a;

例如：一个小的和一个大的计算时 小的提升为大的 然后计算
int a=222;
double b=10.2;
double c=a+b;     //a int自动提升为double

例如：byte、short、char计算时 会提升为int
byte  a=10;
short b=20;
int   c=a+b;       //byte、short、char计算时提升为int
byte  d=(byte)(a+b)   //强转
byte  f=10+20;        //常量的优化机制 相当于byte f=30,将一个这个数复制个欸一个类型时，jvm会判断当前值是否在范围内；

强制转换

要求:

  1. 将数据范围大的 赋予一个数据范围小的

  2. 小数转为整数 只保留整数位

    例如: 将数据范围大的 赋予一个数据范围小的
int a=222;
byte b=(byte)a;

例如：小数转为整数 只保留整数位
double a=10.95;
int b=(int)a;
sout(b);          //10

基础面试题

键盘录入一个小数，输出一个四舍五入的整数

方法1：键盘录入一个小数，输出一个四舍五入的整数
Scanner sc= new Scanner(System.in);
double num=sc.nextDouble();
int result=(int)(num+0.5);
sout(result);

方法2：键盘录入一个小数，输出一个四舍五入的整数
Scanner sc= new Scanner(System.in);
double num=sc.nextDouble();
sout(Math.round(num));
    
拓展：
     向下取整
    Math.floor(num);
例如:
Math.floor(11.7)=11;
Math.floor(-11.2)=-12;

    向上取整
    Math.ceil(num)
例如：
Math.ceil(11.4)=12;
Math.ceil(-11.6)=-11;

键盘录入

用键盘录入数据 为了让我们的数据更加灵活

  1. 导包
    1. 位于类上方
    2. import java.util.Scanner;
  2. 创建对象
    1. Scanner sc=new Scanner(System.in);
  3. 接收数据
    1. int i=sc.nextInt();
例如：
import java.util.Scanner;

public class Demo{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int i=sc.nextInt();
        Sysyem.out.println(i);
    } 
}

标识符

用来给变量 类 方法取名的符号

硬性规范

  1. 数字,下划线,字母,美元符号$
  2. 不能以数字开头
  3. 不可以使用关键字
  4. 严格区分大小写

江湖规矩

  1. 小驼峰
    1. 作用在 变量 方法 上
    2. 一个单词时 首字母小写
    3. 多个单词时 第一个单词首字母小写,其他单词首字母大写
  2. 大驼峰
    1. 作用在 类 上
    2. 一个单词时 首字母大写
    3. 多个单词时 每个单词首字母都要大写

运算符

  • 运算符 用来连接常量或者变量的符号

  • 表达式 使用运算符连接常量或者变量的一种符合Java语法的式子

分类

  1. 算术运算符

  2. 赋值运算符

  3. 比较(关系)运算符

  4. 逻辑运算符

  5. 三元运算符

算数运算符

算数运算符包括：作用
+加法运算，字符串连接运算
-减法运算
*乘法运算
/除法运算
%取模运算，两个数字相除取余数
例如：求三位数的各位数字，十位数字，百位数字是多少？
public class Demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个三位的整数");
        int num = sc.nextInt();
        int ge=num%10;
        int shi=num/10%10;
        int bai=num/100%10;
        //  int qian = num / 1000 % 10;
        //  int wan = num / 10000 % 10;
        System.out.println(ge+" "+shi+" "+bai);
    }
}
字符参与运算：ASCII

作用：字符和byte对应关系 为了让我们方便使用字符

byte、short、char 参与计算时 会提升为int

字符数值
048
957
A65
Z90
a97
z122
例如：
int a=1;
char b='a';
sout(a+b);     //b默认提升为int类型 1+97=98
自增自减运算符
符号作用说明
++自增变量的值加1
–自减变量的值减1

单独使用时，a++，++a，a–，--a相同。

参与运算时，a++ 先拿值在++，++a先++再拿值。

​ a-- 先拿值在–，--a先–再拿值。

例如：
int a=5;
int b=a++ + ++a +5;   // 5  7  5
                      //  6
sout(b);              //17

字符串参与加法运算

字符串参与加法运算得到的结果 也是一个字符串 也叫字符串拼接

从左往右执行 如果有括号先算括号内的

加号两边只要有字符串 结果就是字符串 例如:“你好” + 3 + 4 要考虑到 “你好” + 3结果是一个字符串 所以第二个加号两边存在字符串

sout(2+"你好");    //2你好
sout("你好"+3);    //你好3
sout(2+3+"你好");  //5你好
sout(2+"你好"+3);  //2你好3
sout("你好"+2+3);  //你好23
sout("你好"+(2+3); //你好5

赋值运算符

符号作用说明
=赋值a=10，将10赋值给变量a
+=加后赋值a+=b，将a+b的值给a
-=减后赋值a-=b，将a-b的值给a
*=乘后赋值a*=b，将a×b的值给a
/=除后赋值a/=b，将a÷b的商给a
%=取余后赋值a%=b，将a÷b的余数给a

扩展的赋值运算隐含了强制类型转换 记

例如：
short s = 1;
s+=1;                    //一次运算 相当于 s=(short)(s+1)
sout(s);

比较(关系)运算符

关系运算符就是用来描述两个变量或者常量之间的关系的。

符号说明
==a==b，判断a和b的值是否相等，成立为true，不成立为false
!=a!=b，判断a和b的值是否不相等，成立为true，不成立为false
>a>b，判断a是否大于b，成立为true，不成立为false
>=a>=b，判断a是否大于等于b，成立为true，不成立为false
<a<b，判断a是否小于b，成立为true，不成立为false
<=a<=b，判断a是否小于等于b，成立为true，不成立为false

逻辑运算符

注意: 假设下表中的a和b， 都是boolean类型的值。

符号作用说明
&逻辑与a&b，并且的意思. 有false则整体为false, 都为true, 则整体为true.
|逻辑或a|b，或者的意思, 有true则整体为true, 都为false, 则整体为false.
!逻辑非!a，取反的意思, 以前为true, 取反后为false, 以前为false, 取反后为true.
^逻辑异或a^b，异同的意思, 相同为false, 不同为true.
短路逻辑运算符

在实际开发中, 并且, 或者这样的操作是非常多的, 但是上述的&(逻辑与), !(逻辑或)运算符没有短路效应, 所以效率相对较低, 针对这种情况, 我们可以使用&&(短路与), ||(短路或)来优化.

符号作用说明
&&短路与作用和&相同，但是有短路效果, 前边出现false, 后边不执行.
||短路或作用和|相同，但是有短路效果, 前边出现true, 后边不执行.

解释

  1. 在短路与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值都计算出来，短路与运算符就有这样的效果，可以提高效率。

  2. 同理在短路或运算中，一旦发现值为true，右边的表达式将不再参与运算。

短路和非短路之间的区别
  1. 逻辑与 和 短路与之间的区别

– 逻辑与&(也叫单与): 无论左边真假，右边都要执行。

– 短路与&&(也叫双与): 如果左边为真，右边执行；如果左边为假，右边不执行。

  1. 逻辑或 和 短路或之间的区别

– 逻辑或|(也叫单或): 无论左边真假，右边都要执行。

– 短路或||(也叫双或): 如果左边为假，右边执行；如果左边为真，右边不执行。

记忆: 在实际开发中, 我们用的最多的逻辑运算符就是: &&, ||, ! 记

例如：
public class Demo {
    public static void main(String[] args) {
        boolean x = true;
        boolean y = false;
        short z = 42;                           //真 假 42
        if ((z++ == 42) && (y = true))          //真 真 43
            z++;                                //真 真 44
        if ((x = false) || (++z == 45))         //假 真 45
            z++;                                //假 真 46
        System.out.println("z=" + z);
    }
}

三元运算符

三元运算符也叫三目运算符，即由三部分组成，格式如下：

(关系表达式) ? 表达式1：表达式2；

执行流程:

先执行关系表达式, 看其结果是true还是false.

如果是true, 则执行表达式1

如果是false, 则执行表达式2

例如：三个数字找出最大值
int num1=100;
int num2=111;
int num3=222;
int temp=num1>num2?num1:num2;
int max= temp?num3?temp:num3;
sout(max);

或：//可嵌套 不推荐
int max= (num1>num2?num1:num2)?num3?(num1>num2?num1:num2):num3;

流程控制语句

分类：

• 顺序结构

• 选择结构(if语句, switch.case语句)

• 循环结构(for循环, while循环, do.while循环)

顺序结构

顺序结构指的是代码是按照从上往下，从左往右的顺序,，依次逐行执行的,，且顺序结构也是Java程序的默认结构。

例如：
public class Demo {
    public static void main(String[] args) {
          sout("a");
          sout("b");
          sout("c");
          sout("d");
          sout("e");    // abcde 
    }
}

选择结构(if语句, switch.case语句)

主要分为以下三种:

if语句(也叫: 单分支)

if…else语句(也叫: 双分支)

if…else if语句(也叫: 多分支)

单分支

结构一般用来判断一种情况, 格式如下:

格式

if(关系表达式) {

//语句体;

}

执行流程:

先执行关系表达式，看其结果是true还是false。

如果是true，则执行大括号中的语句体。

如果是false， 则大括号中的语句体不执行。

例如：
public class Demo {
    public static void main(String[] args) {
        sout("开始了");
        int time = 5;
        if(time >= 0 && time <= 8) {
            sout("早上好");
        }
        sout("其他语句");
    }
}
双分支

双分支结构指的是if. else语句, 一般用来判断两种情况, 格式如下:

if(关系表达式) { //if的意思: 如果

//语句体1;

} else { //否则…

//语句体2;

}

执行流程:

先执行关系表达式， 看其结果是true还是false。

如果是true，则执行语句体1。

如果是false，则执行语句体2。

例如：
public class Demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个整数: ");
        int num = sc.nextInt();
        if (num % 2 == 0) {
            System.out.println(num + "是偶数");
        } else {
            System.out.println(num + "是奇数");
        }
    }
}
多分支

多分支结构指的是if. else if语句, 一般用来判断多种情况, 格式如下:

if(关系表达式1) {

//语句体1;

} else if(关系表达式2){

//语句体2;

} else if(关系表达式3){ //这里可以根据需求, 有多个else if语句

//语句体3;

} else {

//语句体n;

}

执行流程

先执行关系表达式1，看其结果是true还是false。

如果是true， 则执行语句体1, 整个if语句结束。

如果是false，则判断关系表达式2, 看其结果是true还是false。

如果是true， 则执行语句体2, 整个if语句结束。

如果是false， 则判断关系表达式3， …以此类推。

如果所有的关系表达式都不成立,，则执行else语句的语句体n，整个if语句结束。

例如：键盘输入小明考试成绩，
    如果小明考试成绩为95~100奖励山地自行车一辆。
    如果小明考试成绩为90~94奖励去游乐园一次。
    如果小明考试成绩为80~89奖励变形金刚玩具一个。
    如果小明考试成绩为0~79男女混合双打。
import java.util.Scanner;

public class Demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入小明的考试成绩: ");
        int score = sc.nextInt();
        if (score >= 95 && score <= 100) {
            System.out.println("奖励小明: 山地自行车一辆");
        } else if(score >= 90 && score < 95) {
            System.out.println("奖励小明: 游乐场玩儿一次");
        } else if(score >= 80 && score < 90) {
            System.out.println("奖励小明: 变形金刚玩具一个");
        } else if(score >= 0 && score < 80){
            System.out.println("奖励小明: 男女双混组合拳 + 扫帚棒法");
        } else {
            System.out.println("考试成绩录入有误.");
        }
    }
}
例如：键盘输入狗子年龄，狗子前两年每年相当于人类10.5年，之后每增加一年就增加四岁，那么狗子五岁相当于人类多少年龄？
import java.util.Scanner;

public class Demo1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入狗狗的年龄：");
        int dogAge = sc.nextInt();
        if (dogAge==1){
            System.out.println("相当于人类10.5岁");
        }else if (dogAge==2){
            System.out.println("相当于人类"+(int)(10.5*2)+"岁");
        }else if (dogAge>2){
            int temp=dogAge-2;
            double age=temp*4+(int)(10.5*2);
            System.out.println("相当于人类"+age+"岁");
        }else {
            System.out.println("输入有误，请重新上输入");
        }
    }
}
switch(byte,short,char,int,枚举,String)…case 值:…

格式：
switch(表达式) {
case 值1：
语句体1;
break;
case 值2：
语句体2;
break;
…
default：
语句体n+1;
[break;]
}

执行流程：
首先计算表达式的值。
依次和case后面的值进行比较，如果有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
如果所有的case后面的值和表达式的值都不匹配，就会执行default里面的语句体，然后程序结束掉。

例如：键盘录入星期数，显示今天的减肥活动。
周一：跑步 
周二：游泳  
周三：慢走 
周四：动感单车
周五：拳击 
周六：爬山 
周日：好好吃一顿 
import java.util.Scanner;

public class Demo {
    public static void main(String[] args) {
        System.out.println("请输入星期数，显示今天的减肥活动");
        Scanner sc = new Scanner(System.in);
        int day = sc.nextInt();
        switch (day) {
            case 1:
                System.out.println("跑步");
                break;
            case 2:
                System.out.println("游泳");
                break;
            case 3:
                System.out.println("慢走");
                break;
            case 4:
                System.out.println("动感单车");
                break;
            case 5:
                System.out.println("拳击");
                break;
            case 6:
                System.out.println("爬山");
                break;
            case 7:
                System.out.println("好好吃一顿");
                break;
            default:
                System.out.println("输入有误，请重新输入");
        }
    }
}

循环语句

for循环

解决什么问题: 当一些需要重复执行的代码 可以循环

格式：

for(①初始化语句；②条件语句，③循环控制语句){

④循环语句体；

}

执行顺序：
1. 初始化语句①
2. 条件语句② 为true 继续往下执行，false循环结束
3. 循环语句体④
4. 循环控制语句③
5. 条件语句②   返回顺序第2步执行

例如：打印输出所有水仙花数。
public class Demo {
    public static void main(String[] args) {
        for (int i = 100; i <= 999; i++) {
            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 100 % 10;
          //int qian = num / 1000 % 10;
          //int wan = num / 10000 % 10;
            if (i == ge * ge * ge + shi * shi * shi + bai * bai * bai) {
                System.out.println(i);
            }
        }
    }
}
需求：在控制台输出所有的“水仙花数”，要求每行打印2个
public class Demo1 {
    public static void main(String[] args) {
        int count=0;
        for (int i = 100; i <= 999; i++) {
            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 100 % 10;
            //int qian = num / 1000 % 10;
            //int wan = num / 10000 % 10;
            if (i == ge * ge * ge + shi * shi * shi + bai * bai * bai) {
                System.out.print(i+" ");           //print 不换行输出
                count++;
                if (count%2==0){
                    System.out.println();           //printlin 不换行输出
                }
            }
        }
    }
}
    

需求：求1-5之间的数据和，并把求和结果在控制台输出
public class Demo {
    public static void main(String[] args) {
        int sum=0;
        for (int i = 1; i <= 5; i++) {
            sum+=i;
        }
        System.out.println(sum);
    }
}    

需求：求1-100之间的偶数和，并把求和结果在控制台输出
public class Demo1 {
    public static void main(String[] args) {
        int sum=0;
        for (int i = 1; i <= 100; i++) {
            if (i%2==0){
                sum+=i;
            }
        }
        System.out.println(sum);
    }
}

while循环

完整格式：

初始化语句①;
while (条件判断语句②) {
循环体语句③;
条件控制语句④;
}

执行流程：
    1. 执行初始化语句①
    2. 执行条件判断语句②，看其结果是true还是false
             如果是false，循环结束
             如果是true，继续执行
    3. 执行循环体语句③
    4. 执行条件控制语句思
    5. 回到2继续

例如：需求：世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，它的厚度是0.1毫米。请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
public class Demo {
    public static void main(String[] args) {
        int zf = 8844430;
        double paper = 0.1;
        int count = 0;
        while (paper < zf) {
            paper *= 2;
            count++;
        }
        System.out.println(count);
    }
}

在控制台打印10次HelloWorld   
public class Demo {
public static void main(String[] args) {
        int i = 0;
        while(i < 10) {
            System.out.println("Hello World!");
            i++;
        }
    }
}

do…while循环

完整格式：
    
初始化语句①;
do {
    循环体语句②;
    条件控制语句③;
}while(条件判断语句④);

执行流程：
    1. 执行初始化语句①
    2. 执行循环体语句②
    3. 执行条件控制语句③
	4. 执行条件判断语句④，看其结果是true还是false
   	   如果是false，循环结束
       如果是true，继续执行
    5. 回到2继续

例如：需求 通过do.while循环, 在控制台打印10次Hello World!
public class Demo {
    public static void main(String[] args) {
        int i = 1;
        do{
            System.out.println("Hello World! " + i);
            i++;
        }while(i <= 10);
    }
}

三种循环之间区别

  1. do…while循环和其他两个循环之间的区别

    1. do…while循环是先执行一次, 后判断。

    2. 而其他两个循环都是先执行判断条件, 然后决定是否执行循环体。

  2. for循环和其他两个循环之间的区别

    1. for循环执行结束后, 初始化条件就不能继续使用了。
    2. 而其他两个循环执行结束后, 初始化条件还可以继续使用.

死循环

在Java中, 死循环的写法格式主要有以下3种:

  1. for(;

    标签：arr,String,int,day06,System,JavaSE,数据,public,out
    来源： https://blog.csdn.net/qq_45925467/article/details/115253894

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

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有