Day_01 基本常识
一.环境安装
jdk:java编程必须具有的环境
idea :集成性比较高,编程体验感很好
eclipse:高校,项目比较老的企业
卸载环境(当你去了公司,要进行工具的版本统一或者其他工具的使用和安装的时候),去计算机控制面板卸载软件
1.jdk环境安装
找到jdk的安装包
jdk默认安装在 ,自动生成一个叫java的文件
安装jre
2.配置环境,因为jdk在电脑上不能直接自己默认打卡使用,所以我们需要对jdk环境进行配置,让其能够在系统目录中被找到
找到你安装jdk的目录,然后找到jdk的文件夹,复制这个目录
找到你的此电脑,右键打开"属性",打开窗口找到"高级系统设置"
找到"环境变量"
找到系统变量
点击"新建"新建系统变量
点击path添加系统设置
进行检查(cmd输入javac java验证)
二.jdk&jre
jre:是java的运行时环境,包含了java虚拟机,java基础类库.是使用java语言编写的程序运行所需要的软件环境,是提供给想要运行java程序的用户使用的
jdk:是java程序的开工具包,是使用JAVA语言编写java程序所需要的开发工具包,提供给程序员使用
jdk里面包含了jre,同时还包含了java源码的编译器:javac.如果你仅仅需要运行一个java程序,那么你只需要有一个jre就可以了.但如果你需要对java程序进行编写,那么你就需要jdk
三.如何在运行窗口执行java文件
新建一个文件夹"Day_01"
在文件夹中新建一个文件叫做"Demo_01"
在文件中写一个程序
publicclassDemo_01{
publicstaticvoidmain(String[] args){
System.out.println(10.0*10.2/3);
}
}
注意:
文件中Demo_01是类的名称,必须和文件名相同
整个文件中无论字母还是符号都必须是英文
输出语句System.out.println("")后必须加";"因为代表这句话已经写完了
将文件重新命名,将".txt"的后缀改成".java"
打开输入窗口,输入"cmd"
如何在运行窗口中执行代码
1.使用win+r ,输入cmd,进入到运行窗口
2.切换盘符,比如你的程序在d盘,"d:"然后回车
3.比如我要进入某个目录"cd目录名"然后回车
4.如果想要返回上一级目录"cd.."
5.我们要对源文件进行编译处理
将我们能够看懂的.java文件使用,javac进行编译,然后编译成为电脑能看懂的.class文件
6.当一个文件中有多个class修饰类的时候,我们对文件进行编译,能够参数多个class文件.并且每个.class文件都能单独执行
7.一个java文件可以定义多个类
8.如果你对一个.java文件进行了修改,但没有重新对文件进行编译,name我们执行.class文件时,任然是之前的内容.我们使用javac进行编译的时候,产生的新文件会将原来的文件进行覆盖
9.执行.class文件:"java文件名",注意没有后缀名,比如javaA
我们能看懂的是.java文件,电脑能够看懂的是字节码文件
当我们将程序写好之后,这个程序我们自己能够看得懂但是电脑无法编译,于是我们就使用javac对文件进行编译处理,编译完成之后,就会生成电脑能够看得懂的.class文件,这个过程叫编译
当电脑将程序执行完毕之后,会产生一个结果,那么这个结果也是编译之后的结果,是电脑能够看懂的,是字节码文件,我们需要将其翻译为用户能够看懂的信息,这个过程叫反编译
四.安装idea
五.idea的使用
选择模式
新建项目模式选择
设置项目名和存储的目录
新建一个模块
六.idea项目中的目录结构
项目:project
src:这个文件夹是存放在java文件的根目录中
包(package):作用是将具有相同格式或者性质的文件分包进行处理
右键单击src--->new------>packgae
包的名称使用域名倒置的写法.例如:淘宝中的包为;com.taobao.项目名称
类(class):存放在包中,并且是参与程序执行的最小单元
类的名称使用
首字母大写
只能使用字母,数字,下划线(_),美元符号
数字不能作为开头
不能使用关键字
使用驼峰式命名法,每个单词的首字母大写
做到见名知意,一个包中不能有相同的类名
七.注释
注释是给人看的,电脑不执行
//单行注释,只对一行起作用
/**/多行注释,能够对多行起作用
/** */文档化注释,能够生成api文档 使用javadoc 文件.java
八.分隔符
一条语句是以分号";"结尾的一行代码
一个语句是以一对花括号"{}"为边界的语句的集合
java中运行有任意多个换行和空格,包括","以及";"
九.标识符
概念:给变量,类,方法,包,取名字的
要求:
1.由字母,数字,下划线,美元符号组成
2.不能以数字开头
3.严格区分大小写
4.不能使用关键字
true false null 不是关键字,但也不要和这些单词同名
5.见名知意
6.不要和jdk中已经存在的类和接口重名
7.要求命名符合阿里巴巴的编程公约
十.关键字
java中有50个关键字，关键字就是一些赋予了特殊作用的小写单词
不用死记硬背
数据类型:
byte short int long float double char boolean
和包相关的:
package import(导入)
访问控制修饰符
public protected private
流程控制:
if else switch case defult for while do break continue
保留字
goto const
异常相关的:
throw throws try catch finally
和方法相关的:
void return
修饰符:
class abstract static fianl interface enum(枚举)
和对象相关:
new this super instanceof
类与类的关系,类与接口之间的关系:
extends implements
其他:
native strictpf synchronized stransient volatile assert
十一.数据类型
基本数据类型
整型:byte(字节型) short(短整型) int(整型) long(长整型)
浮点型:float(单精度浮点型) doublean(双精度浮点型)
字符型:char(''单个元素,使用单引号引起来)
布尔型:boolean(判断对错)
引用数据类型
数组
接口
类
...
今日代码
Dome_01
packagecom.softeem.basic;
/*
这是第一个java程序
*
* */
publicclassDemo_01 {
/*
主方法:
是程序的入口,程序是否可以正常执行,主要看主函数是否存在以及正确
主函数的写法只有一种
主函数在一个类中只能有一个(有且仅有一个)
想要执行一个程序,name程序必须写在主函数中或者在主函数中进行调用
String后面的 args 其实是一个数组的名称,我们给主函数传输信息的时候,
最后都是以数组的形式参与
args是可以改成别的名字,但一般不建议改变
* */
publicstaticvoidmain(String[] args) {
/*
输出语句
输出语句的写法也基本固定
一个程序中可以有多个输出语句
输出语句如果输出的是一句话,那么我们就将这句话放在输出语句括号中的双引号中
如果输出语句是一个运算,或者一个变量,那么我们就将信息放在输出语句的括号中,不使用双引号
*
* */
//系统 输出 打印
System.out.println("今天上课好困");
//print:表示输出这一句话之后,下一句话在这个输出语句后面继续输出
//println:表示输出完这一句话之后,下一句换行输出
System.out.println(100*20);
}
}
Day_02 数据类型&运算符
一.java语言的发展历史
1991年开始出现,1995正式开始发布
出生地:sun公司,后来被oracle收购
最新的版本:jdk19 (咱们用的是8)
java的体系:
javaSE 标准版 java基础,桌面应用开发
javaEE 企业版 javaweb ,网站
javaME 微型版 被安卓取代
java语言的特点:
一次编译到处执行,不分平台,因为我们最终执行的是.class文件,只要你的电脑上有jre文件...
二.变量
概念
能够存储计算结果或者表现值的抽象概念,变量可以通过名词进行访问
变量相当于一个容器,我们在定义变量的时候,就相当于定义了一个指定数据类型的容器来存储相应的信息
Demo_01(变量)
packagecom.softeem.basic;
/*
变量
成员变量(全局变量):
局部变量:
* */
publicclassDemo_01 {
/*区别 1:定义位置不同
区别 2:在内存中存储的位置不同
区别 3:作用的范围不同
区别 4:默认的值不同
变量的语法:
数据类型 变量名 = 值;
* */
staticintage;
staticdoubleprice=99.99;
staticcharsex='男';
Strings="aaa";
publicvoida(){
System.out.println(s);
}/*
没有static的方法,可以调用全局变量中有static的变量,也可以调用不含static的全局变量
*/
publicstaticvoidmain(String[] args){
/*
含static的方法,只能调用局部变量和包含static的全局变量
* */
intm ;
doublen=25.5;
charb='中';
System.out.println("age = "+age);
/* System.out.println("m = " + m);*///m未被调用
Demo_01q=newDemo_01();//方法a 必须经过调用才能输出
q.a();
}
}变量三要素
数据类型 变量名 = 值;
拆分成两个步骤:
//声明变量(定义变量)
//在计算机的内存中开辟一个空间,用来存储元素
数据类型变量名; intage;
//赋值
变量名=赋值; age=18;
解释:
1.变量名的命名必须符合标识符的命名规范,阿里编程规约中变量名使用小驼峰式命名法,第一个单词首字母小写,从第二个单词开始首字母大写studentName
2.基本数据类型与引用数据类型
3.值必须匹配合适的数据类型
4.变量通常是可以改变的,可以重复进行赋值 ,比如;age=18; 重新赋值age=19;
数据类型
基本数据类型
整型(整数): byte(字节型) short(短整型) int(整型) long(长整型)
浮点型(小数): float(单精度浮点型) double(双精度浮点型)
字符型(一个字符): char
布尔类型(判断对错): boolean
引用数据类型:除基本类型之外都是引用数据类型
String:比一些基本数据类型还常用的引用数据类型,表示对字符串的处理
变量的区别
成员变量(全局变量) | 局部变量 | |
定义的位置不同 | 定义在类里面,也就是class后面的类名的大括号中 | 定义在方法或者代码块中,如果说是方法的参数,也是局部变量 |
作用域不同 | 整个类可以使用 | 在方法或者代码块中使用 |
初始值不同 | 如果没有给变量进行赋值,java的系统会给变量一个初始值 | 必须手动赋值才能使用 |
内存存储位置不同 | 堆里面,和对象的生命周期一致 | 存储在栈里面,和方法的生命周期一致 |
注意事项:
1.在同一个作用范围之内,变量名不能相同
2.intb=3.33;错误的,变量的值必须和变量的数据类型保持一致
3.name="zhangsan"; 错误的,变量必须先声明再进行赋值
4.intx; System.out.println(x);
x是局部变量就会报错,因为这个变量必须进行初始化定义就必须给其一个值
如果是成员变量,那么计算机会自动赋值,并且这个值为初始值
整数类型(四种)
字节数 | 取值范围 | |
byte 字节型 | 1(8位) | -2^7 ~ 2^7-1[-128 ~ 127] |
short 短整型 | 2(16位) | -2^15 ~ 2^15-1[-32768 ~ 32767] |
int 整型 | 4(32位) | -2^31 ~ 2^31-1 |
long 长整型 | 8(64位) | -2^63 ~ 2^63-1 |
Demo_02(整型)
packagecom.softeem.basic;
/*
整型
byte short int long
1.在整数中,我们没有特殊要求,就使用int类型
2.当byte类型和short类型在进行算术运算的时候,默认转换为int类型
3.当给long类型进行赋值的时候,如果超过了int类型的范围,我们要在赋值的数后面加一个L或者l
*
* */
publicclassDemo_02 {
publicstaticvoidmain(String[] args) {
//整数类型进行赋值
bytea=100;//将100这个值赋值到byte类型的变量a中
intb=a;//将a的值赋值一份给b
//我们给short类型进行赋值的时候,会自动转换成int类型,或者
// 如果你必须使用short类型进行处理的话,我们必须进行数据类型之间的强制类型转换
shortm1=10;
shortm2=10;
intm3=m1+m2;
System.out.println("int类型最大值: "+Integer.MAX_VALUE);
System.out.println("long类型最大值: "+Long.MAX_VALUE);
//当我们给long类型进行赋值的时候,如果超过了int类型的最大值范围,那么我们就
//在赋值的数后面加上一个L或者l,一般我们使用L,因为在一些编译器或者不同的开发字体中
//小写的 l 与数字1比较相似,我们在进行处理的时候容易出现错误
longp1=2147483647;
longp2=9223372036854775807L;
}
}Demo_03(定义 2 ,8,10,16进制)
packagecom.softeem.basic;
/*
如何定义2,8,10,16进制
* */
publicclassDemo_03 {
publicstaticvoidmain(String[] args) {
//二进制使用0b进行开头
inta=0b10;
System.out.println("a : "+a);
//八进制使用0开头
intb=010;
System.out.println("b : "+b);
//十进制
intc=20;
System.out.println("c : "+c);
//十六进制0x开头 0 1 2 3 4 5 6 7 8 9 A B C D E F
intd=0x10;
System.out.println("d : "+d);
}
}浮点类型(2种)
float | double | |
名称 | 单精度浮点型 | 双精度浮点型 |
字节 | 4 | 8 |
精度问题 | 保留小数点后8位 | 保留小数点后16位 |
Demo_04(浮点型)
packagecom.softeem.basic;
importjava.math.BigDecimal;
/*
浮点型
1.默认使用double类型
2.给浮点型进行赋值整数的时候,能够自动转换为小数输出
3.如果给float进行赋值,是一个小数,我们需要在赋值的数后面加一个 F 或者 f 的后缀
4.小数在进行运算的时候可能会出现精度丢失的问题,在java中已经出具一个特殊的类,专门进行小数精度确认
* */
publicclassDemo_04 {
publicstaticvoidmain(String[] args) {
//给浮点类型赋值整数
doublea=10;
System.out.println("a "+a);
//给double类型赋值小数
doubleb=3.5;
System.out.println(" b"+b);
//如果给float进行小数赋值的时候,我们需要在赋值的数后面加F 或者 f
floatc=3.5F;
System.out.println("c "+c);
//float接收整数的时候不需要加后缀
floatd=50;
System.out.println("d "+d);
//在计算机的运算过程中,首先将小数转换成二进制,然后使用二进制进行计算,
// 计算完成后,再将元素转换为十进制,在转换的过程中就会出现小数运算精度丢失的问题
doublek1=0.01;
doublek2=0.05;
System.out.println(k1+k2);//0.060000000000000005
//想要进行精度运算,要先对java本身已经提供的精度运算的类进行创建对象
//创建对象的语法: 类名 对象名 = new 类名()
BigDecimald1=newBigDecimal("0.01");//以字符串的形式将元素放进来
BigDecimald2=newBigDecimal("0.05");
//怎么计算?
//加:对象名.add(第二个对象名)
//除:对象名.divide(第二个对象名)
//乘:对象名.multip(第二个对象名)
//减:对象名.substract(第二个对象名)
System.out.println(d1.add(d2));
System.out.println(d1.divide(d2));
BigDecimalc1=newBigDecimal("0.99");
BigDecimalc2=newBigDecimal("0.95");
System.out.println(c1.divide(c2));
}
}
boolean类型
只有true和false两个值
但是这两个类型经常使用,使用在分支,三目运算符,逻辑运算符,比较,for循环中...都有使用
因为我们需要使用判断的场景的时候就需要使用boolean类型进行比较
Demo_05(布尔类型)
packagecom.softeem.basic;
/*
boolean类型
只有true和false两个值
但是这两个类型经常使用,使用在分支,三目运算符,逻辑运算符,比较,for循环中...都有使用
因为我们需要使用判断的场景的时候就需要使用boolean类型进行比较
* */
publicclassDemo_05 {
publicstaticvoidmain(String[] args) {
booleana=true;
booleanb=false;
booleanc=10>20;
System.out.println("c = "+c);
}
}
字符型
char类型: 范围 0~ 65535
常用的赋值方式
ASCII码值
unicode码值: 统一码,单一码,万国码,为世界上的每一种语言的每一个字符设置了统一并且唯一的
二进制编码
表现形式为:单引号中添加了一个前缀\u 然后使用十六进制进行元素内容表示
中文的范围是:
4E00 ~ 9FA5
整型和char类型之间相互赋值
一些特殊符号使用
Demo_06(字符型)
package com.softeem.basic;
/*
char类型: 范围 0~ 65535
1.常用的赋值方式
2.ASCII码值
3.unicode码值: 统一码,单一码,万国码,为世界上的每一种语言的每一个字符设置了统一并且唯一的
二进制编码
表现形式为:单引号中添加了一个前缀\u 然后使用十六进制进行元素内容表示
中文的范围是:
4E00 ~ 9FA5
4.整型和char类型之间相互赋值
5.一些特殊符号使用
*
* */
public class Demo_06 {
public static void main(String[] args) {
/*
常用的赋值方式
语法:
char 变量名 = '值'
值只能是一个,并且不能没有
可以是字母,实在,汉字,符号
*
* */
char a1 = 'a';
char a2 = 'A';
char a3 = '1';
char a4 = '中';
char a5 = ' ';//放了一个空格
/*
常识
ASCII码:美国信息交换标准码,是一套编码方案,能够帮我们进行元素之间信息的转换
一共0 ~ 127共 128个字符
32:空格
48 ~ 57 : 0~9
65 ~ 90 : A ~ Z
97 ~ 122 : a ~ z
可以直接对char类型进行整数类型赋值
或者将一个整数值,赋值给一个char类型
* */
//整数赋值给char
char b1 = 98;//这里没有报错是因为计算机内部已经将其转换为ASCII码对应的值
System.out.println("b1 = " + b1);
//字符赋值给整数
int b3 = '刘';
System.out.println("b3 = " + b3);
char b2 = 23456;
System.out.println("b2 = " + b2);
}
}数据类型强制转换
自动转换:小的数据类型转大的数据类型
强制转换:大的数据类型转小的数据类型
byte < short < int < long < float < double
^
|
char
八种基本数据类型中除了boolean类型之外其余的数据类型之间都可以进行相互转换
Demo_07(数据类型强制转换)
package com.softeem.basic;
/*
byte < short < int < long < double
* */
public class Demo_09 {
public static void main(String[] args) {
//自动转换
//小的转大的
//byte 水杯 int 水桶 double 水缸
//int 类型和char类型之间可以相互转换,某些情况下可以直接转换
//除了boolean类型之外,其余数据类型直降都可以相互转换
//
byte a1 = 10;//将10 这个值赋值给byte类型的变量a1
int a2 = a1;
System.out.println(a1);
System.out.println(a2);
double a3 = a2;
System.out.println(a3);
//强制转换
//大的转小的
double b1 = 35.999;
//你最终要将一个元素转换成什么类型,就在这个变量或者数据面前添加"(最终转化的数据类型)"
//最终的数据类型 变量名 最终转换的数据类型 原始数据或者原始变量
int b2 = (int) b1;
System.out.println("b1 = " + b1);
System.out.println("b2 = " + b2);
int c1 = 122;
byte c2 = (byte)c1;
System.out.println("c2 = " + c2);
//int
Integer age = 18;
System.out.println("age = " + age);
//char类型的最大值是:65535
//char的最小值是:0
//最大值最小值输出的应该是一个整数值,现在char类型是一个字符
//我们就需要将字符类型转换为基本数据类型中的int类型
System.out.println("char类型的最小值是 : " + (int)Character.MIN_VALUE );
System.out.println("char类型的最大值是 : " + (int)Character.MAX_VALUE );
}
}三.数据类型相关的面试题
1.byte b1 = 1;b1 = b1 + 1;这个变量的定义和元素相加有什么错?
b1本身是byte类型,1是int类型,两个元素相加之后,最终是int类型,但是在b1上面进行变量定义的时候是byte类型,所以在这里第二句程序元素会出现赋值错误.并且提醒要求更改数据类型
如果b1 += 1;会不会出现错误?
这个表达式不会出现错误,因为 += 这种扩展的赋值运算符会进行自动的类型转换
2.char类型变量能不能存储一个中文汉字?为什么?
一个中文汉字在内存中占多数个字节 char类型是两个字节16位,可以使用unicod编码表示 只要在unicode编码表示的范围内,就都可以存储在char类型中.但是有一些生僻字或者没有录入到unicode编码中的汉字存在着存储错误 如果使用utf-8编码格式进行处理的时候,一个汉字占三个字节,如果使用gbk进行表示,一个汉字占两个字节
3.能否在不进行轻质转换的情况下,讲一个double类型的变量赋值给long类型变量
不可以,虽然double类型和龙类型都是占8个字节(64位),但底层的存储结构是不一样的,double表示的范围>long表示的范围,所以想要将一个double类型变量赋值到龙类型不经过强制转换是不可以的
4.在java中 3 * 0.1 == 0.3?结果是否返回为true或者false
为false,因为在float和double类型进行小数运算的时候,会出现精度丢失的问题,所以这个表达式值为false
四.基本数据类型和其他封装类型
封装类型 | Byte | Short | Interger | Long | Float |
基本类型 | byte | short | int | long | float |
封装类型 | Double | Character | Boolean | ||
基本类型 | double | char | boolean |
基本数据类型:
一般我们只进行定义变量或者计算的时候使用
封装类型:
一般是将我们对基本数据类型的属性以及各种方法放在封装类型所代表的类中,然后我们可以根据封装类型提供的方法来进行特殊元素的操作
基本数据类型,就相当于一个商品的名称,只是一个指代性的东西,具体商品是什么样子,有什么样的功能,具体的内容都是在封装类中进行处理的,我们可以根据封装类型来进行元素信息的获取
五.运算符
1.算术运算符
package ysf;
import org.w3c.dom.ls.LSOutput;
/*
算术运算符,主要用来对变量进行计算的时候使用
+ - * /(除法) %(取余) ++(自增) --(自减)
* */
public class Demo_01 {
public static void main(String[] args) {
//1.整数和整数之间运算,得到的一定是整数
int a = 10;
int b = 6;
double c = 3 ;
int d = 3;
System.out.println( a + c );//一个是int 一个是double类型,最终的结果就是double类型
System.out.println(( a + b )/ d);
//2.取余运算
int m1 = 20;
int m2 = 6;
System.out.println(m1 % m2);
//取余的结果的符号只与前面的数相关,并且和前面的数保持一致
System.out.println(10 % 3);
System.out.println(10 % -3);
System.out.println(-10 % 3);
System.out.println(-10 % -3);
//3.加号的额用法
//在没有遇到字符串之前,所有的加号都是运算符
//在遇到字符串之后,所有的加号都是连接符,除非将两个想要相加的元素括起来,那么这个元素会变成一个整体先进行运算
int y1 = 20;
int y2 = 100;
//y1 + y2 = 120
//输出语句中输出变量名称,就代表这个变量是什么样的值
//在处理变量中的数据的时候,我们只需要取到变量名就可以了
//如果在一个运算中,元素或者变量中出现了字符串(就是用双引号引起来的元素)
//我们后面所有的加号都是连接符
//先算括号里面的
System.out.println(y1 + "+" + y2 + "=" + (y1 + y2));
// ++ 自增
// -- 自减
//加号放前面,先对这个数本身进行加 1 处理,然后再将改变之后的元素进行算术运算,或者输出
int t1 = 10;
System.out.println(++t1);//11
System.out.println(t1);//11
//加号放在后面,先拿这个数本省进行算术运算或者输出,然后当使用完毕后,再对这个数进行加1处理
int t2 = 10;
System.out.println(t2++);//10
System.out.println(t2);//11
int t3 = 10;
// 10 + 10 当这里运算完成之后t3就会变成11
int r = 10 + t3++;
// 20 - 10
int o = 20 - --t3;//因为减号放在前面,所以我们对原来的数先进行减1处理,然后再进行运算
System.out.println("r = " + r);//20
System.out.println("o = " + o);//10
System.out.println("t3 = "+ t3);//10
}
}2.比较运算符
package ysf;
/*
比较运算符
> < == != >= <=
最终的结果都是boolean类型
* */
public class Demo_02 {
public static void main(String[] args) {
System.out.println(100>200);//flase
System.out.println(100 < 200 );//true
//两个等于对于基本数据类型而言,比较的是值,对于引用数据类型而言比较的是地址
String s1 = "abc";//信息进去之后存储在常量池中,如果s2和他相同那么就直接将s1的存储信息的地址给到s2,
// 相当于s1和s2使用了相同的内容
String s2 ="abc";
//创建对象,无论是否已经有信息存储进去了,都会在计算机的内存中重新开辟空间
String s3 = new String("abc");
System.out.println(s1 == s2 );//true
System.out.println(s1 == s3);//false
//想要比较两个字符串内容是否相同,使用:.equals
//语法: 原始字符串.equals(其他字符串)
//不忽略大小写进行字符串的内容比较
System.out.println("abc".equals("Abc"));
//忽略大小写之后进行字符串的内容比较
System.out.println("abc".equalsIgnoreCase("ABC"));
}
}3.赋值运算符
package ysf;
/*
赋值运算符
+= -= *= /= %=
* */
public class Demo_03 {
public static void main(String[] args) {
int m = 20 ;
m *= 6 ;// m = m * 6 m与6进行乘法运算,运算完成后将最终的值赋值给他本身
System.out.println("m = " + m);
byte n = 11;
n += 5;// n = n + 5; 在本身的基础上进行加5的运算,然后赋值给它本身,并且自动进行类型转换
System.out.println("n = " + n);
}
}4.逻辑运算符
package ysf;
/*
逻辑运算符,最终的结果也是boolean类型
&:与,当两个元素之间进行运算的时候,如果两个值的结果都是true
name最终结果才是true,有一个false结果就是false
|:或,当两个元素之间进行运算的时候,有一个true结果就是true
!:非,取相反,值是true,结果就是false.值是false,结果就是true.
^:异或,如果两个结果相同就是false,如果不同就是true
&&:短路与 : 只要执行的过程中发现有一个值是假的,那么久=就得出结论,不再往后进行计算
||:短路或 : 只要执行的过程中发现有一个值是真的,那么久=就得出结论,不再往后进行计算
结果和正常 与 和 或 没有什么区别,但是在运算的过程中会有所不同
* */
public class Demo_04 {
public static void main(String[] args) {
// &; 一假即假
System.out.println(80 > 70 & 50 < 40 );//false
System.out.println(1 > 2 & 2 > 1);//true
// |: 一真即真
System.out.println(80 >70 | 70 < 80);//true
System.out.println(70 > 80 | 80 < 70);//false
// !: 取反
System.out.println(!(100 > 20));//false
// ^: 同假异真
System.out.println(100 > 200 ^ 100 < 200);//false
int a = 10;
int b = 20;
//不短路的情况下会从头到尾进行运算
System.out.println(100 > 200 | 200 < 300 | a++ > ++a);
System.out.println("===" + a);
System.out.println(100 > 200 || 200 < 300 || b++ > ++b);
System.out.println("===" + b);
}
}5.三目运算符
package ysf;
/*
三目运算符:
?:
语法:
表达式 ? 值1 ; 值2;
表达式是一个结果为boolean类型的值,可以是比较运算,也可以是逻辑运算
表达式的结果如果是正确的,那么就选择值1,如果是错误的就选择值2
* */
public class Demo_05 {
public static void main(String[] args) {
System.out.println(100 < 20 || 100 > 200 ? "100比较大" : "200比较大");
int m = 10;
int n = 10;
//如果三目运算表达式的值要复制给一个变量,那么要保证m和n
int w = m++ > ++n || n++ < ++m ? m : n;
}
}Day_03 位运算 & Scanner & Random & 流程控制
一.位运算符
1.特点:
在处理数据的时候比较快,因为我们计算机本身就是二进制的,当我们输入一个十进制的时候,计算机内部也是以2进制的形式处理的 ,但在我们平时完成代码的过程中,这个内容用得比较少
2.方法：
辗转相除法
用2整除十进制数,又会得到一个商和余数;
又用2除以商,又会得到一个商的余数
如此重复,直到商小于1的时候,我们将先得到的余数作为二进制的最低位,然后的得到的余数作为二进制高位然后排列起来
3.位运算符(种类)(取反正负有问题)
&:按位与:如果两个都为1,那么结果就是1,中间有一个0,结果就是0
|:按位或:如果有一个为1,结果就为1
^:按位异或:(同假异真)
~:按位取反:将0变成1,将1变成0
.>>有符号右移: m >> n,将m转换为二进制,然后向右移动n位
如果m为正数,就在前面补n个0
如果m为负数,就在后面补n个0
<<左移: m << n,将m转换为二进制.然后向左移动n位
不分正负号,然后在后面补n个0
.>>>无符号: m >>> n 将m转换为二进制,向右移动n位
不分正负号,然后在前面补n个0
原码:正数的二进制原码,就是使用辗转相除法取出的原来的数,负数的原码是想对其进行取绝对值,然后对其绝对值进行二进制转换
反码:将原来原码的数值进行取反
补码:在反码的基础上加1的处理
负数转二进制
以-9为例,演示如何将其转换成二进制数,使用辗转相除法进行二进制处理的时候取出的是余数
9: 1001 叫原码
对上面的数进行原码取反,得到反码
1111 0110
补码是在反码的基础上加1
1111 0111
将二进制负数转换成十进制,将1111 0111进行减1处理,庵后对这个数进行取反,再对其进行相反数操作
4.位运算符优先级
优先级 | 运算符 | 类 | 结合性 |
1 | () | 括号运算符 | 由左至右 |
2 | [ ] | 方括号运算符 | 由左至右 |
3 | ! +(正号) -(符号) | 一元运算符 | 由右至左 |
4 | ~ | 位逻辑运算符 | 由右至左 |
5 | ++ . -- | 递增与递减运算符 | 由右至左 |
6 | * . / . % | 算术运算符 | 由左至右 |
7 | + . - | 算术运算符 | 由左至右 |
8 | << . >> | 位左移.位右移运算符 | 由左至右 |
9 | > . >= . < . <= | 关系运算符 | 由左至右 |
10 | == . != | 关系运算符 | 由左至右 |
11 | &(与) | 位逻辑运算符 | 由左至右 |
12 | ^(异或) | 位逻辑运算符 | 由左至右 |
13 | |(或) | 位逻辑运算符 | 由左至右 |
14 | && | 逻辑运算符 | 由左至右 |
15 | || | 逻辑运算符 | 由左至右 |
16 | ? : | 条件运算符 | 由右至左 |
17 | = | 赋值运算符 | 由右至左 |
二.Scanner
Scanner;扫描器
packagecom.softeem.sca;
importjava.util.Scanner;
/*
Scanner;扫描器
作用就是将用户输入到控制台的信息获取到
是一个java提供好的类
* */
publicclassDemo_01 {
publicstaticvoidmain(String[] args) {
/*
1.创建对象
类名 对象名 = new 类名();
Scanner 的扫描器除了对象名自己定义,其余都是已经固定好的
2.导包:找到这个类在java类库中的地址 光标放在报错的位置 alt + 回车
找到import class ,找到系统工具包
* */
//系统输入: System.in 系统输出: System.out 打印输出: println
Scannersc=newScanner(System.in);
//3.你要告诉你的用户应该输入什么东西
System.out.println("请输入你的年龄: ");
//需要一个变量来接收用户输入的信息
//当我们输入完成信息之后,需要按下回车键,告诉电脑,我已经输入完毕了
//sc就是上面的扫描器,nextInt():扫描器中的方法要到控制台中去找一个整数型元素,给到变量
intage=sc.nextInt();
System.out.println("age = "+age);
}
}
InputMismatchException:异常
当我们输入的信息和计算机需要接收的信息不相符的时候,就会出现这个异常内容
需要我们对输入的信息进行类型或者范围的更改
packagecom.softeem.sca;
importjava.util.Scanner;
/*
InputMismatchException:异常
当我们输入的信息和计算机需要接收的信息不相符的时候,就会出现这个异常内容
需要我们对输入的信息进行类型或者范围的更改
* */
publicclassDemo_02 {
publicstaticvoidmain(String[] args) {
//创建对象
Scannersc=newScanner(System.in);
System.out.println("请输入商品名: ");
Stringname=sc.next();
System.out.println("请输入商品价值");
doublemoney=sc.nextDouble();
System.out.println("请输入商品数量");
intsum=sc.nextInt();
System.out.println("商品名为: "+name);
System.out.println("商品价格为: "+money);
System.out.println("商品数量为: "+sum);
}
}Scanner可以输入哪些值
packagecom.softeem.sca;
importjava.util.Arrays;
importjava.util.Scanner;
/*
Scanner可以输入哪些值
* */
publicclassDemo_03 {
publicstaticvoidmain(String[] args) {
Scannersc=newScanner(System.in);
Stringsex=sc.next();
char[] s=sex.toCharArray();//将字符型转换成字符数组
System.out.println(Arrays.toString(s));
charss=s[3];//取出数组中某一个位置的值
System.out.println("ss ="+ss);
bytea=sc.nextByte();
shortb=sc.nextShort();
intc=sc.nextInt();//常用
floatd=sc.nextFloat();
doublee=sc.nextDouble();//常用
booleanf=sc.nextBoolean();//常用
//除了char类型之外八种基本数据类型,都可以使用Scanner进行接收
//如果想要进行char类型元素的获取,就使用String类型
}
}三.Random
随机数,伪随机数
packagecom.softeem.ran;
importjava.util.Random;
importjava.util.Scanner;
/*
随机数,伪随机数
* */
publicclassDemo_01 {
publicstaticvoidmain(String[] args) {
//创建对象
//类名 对象名 = new 类名();
Randomr=newRandom();
//默认生成一个0-1之间的小数,包含0但是不包含1
doublea=r.nextDouble();
System.out.println("a = "+a);
//生成int范围内的数
intb=r.nextInt();
System.out.println("b = "+b);
//生成0 ~ n之间的整数,包含0,但不包含n
intc=r.nextInt(100);
System.out.println("c = "+c);
//手动输入一个整数n,然后生成0 ~ n之间范围内的随机数
Scannersc=newScanner(System.in);
System.out.println("请输入一个最大值: ");
intmax=sc.nextInt();
intk=r.nextInt(max);
//生成65 ~ 90之间的整数,然后将其转换成char类型字符输出
//生成两个数之间的,从那个数开始,就加哪个数
}
}
在数学类实现随机数生成
packagecom.softeem.ran;
/*
Math.random
在数学类中有一个方法,能实现随机数生成
*
* */
publicclassDemo_02 {
publicstaticvoidmain(String[] args) {
//默认生成 0 - 1 之间的小数 ,包含0 但不包含1
doublea=Math.random();
System.out.println(" a = "+a );
//生成0~100 之间的随机小数
doubleb =Math.random()*100;
System.out.println(" b = "+b);
//生成0 ~ 100 之间的整数
//(int)Math.random()*100;是由两部分组成的,一部分是用来产生随机数的Math.random()
//另一部分是100,如果我们直接对(int)Math.random()进行强制转换取整,我们只能得到一个整数0
//然后0乘以任何数都为0,我们需要将后面相乘的部分进行整体运算再取整
intc= (int)(Math.random()*100);
System.out.println(" c ="+c );
//要生成97 ~ 122之间的整数,包含97和122
intd=97+ (int)(Math.random()*26);
System.out.println("d = "+d);
}
}
四.流程控制
分支语句是一个代码块,在我们项目过程中是很常用的一个技术根据我们的需求进行程序的执行
if(条件表达式){ }
语法:if(条件表达式){ 执行语句}执行过程; 如果条件表达式符合,就执行语句内容.不符合就不执行
当只有一个判断条件并且只有一条语句的时候,我们可以省略大括号不写
packagecom.softeem.fz;
importjava.util.Scanner;
/*
分支语句是一个代码块,在我们项目过程中是很常用的一个技术
根据我们的需求进行程序的执行
语法:
if(条件表达式){
执行语句
}
执行过程;
如果条件表达式符合,就执行语句内容.不符合就不执行
注意:当只有一个判断条件并且只有一条语句的时候,我们可以省略大括号不写
* */
publicclassDemo_01 {
publicstaticvoidmain(String[] args) {
Scannersc=newScanner(System.in);
System.out.println("请输入您的年龄:");
intage=sc.nextInt();
if (age>=18){
System.out.println("您已经成年");
}
if (age>=0&&age<=120){
System.out.println("您输入的年龄范围正确");
if (age<18){
System.out.println("您当前未成年");
}
}
}
}
if(条件语句){}else{}
packagecom.softeem.fz;
importjava.util.Random;
/*
语法:
条件表达式是一个boolean类型的值
if(条件表达式){
语句1
}else{
语句2
}
当条件表达式为true时,就执行语句1
当条件表达式为false时,就执行语句2
随机一个0 ~ 100 之间的整数,判断这个数是不是3的倍数,或者是否包含 3
* */
publicclassDemo_02 {
publicstaticvoidmain(String[] args) {
Randomrandom=newRandom();
System.out.println("请输入一个数");
inta=random.nextInt(100);//0~ 100 的随机数
if (a%3==0||a%10==3||a%10==3 ){
System.out.println(a+"是3的倍数,或者包含3");
}else{
System.out.println(a+"不是3的倍数,或者不包含3");
}
}
}if(){}else{}else...
packagecom.softeem.fz;
importjava.util.Random;
/*
if(条件表达式){
语句1
}else if(条件表达式2){
语句2
}else if(条件表达式3){
语句3
}...
else{
语句n
}
执行过程:
哪个条件表达式的结果为正确,就执行哪个语句,如果条件表达式都错误,那么就执行最后一个语句
* */
publicclassDemo_03 {
publicstaticvoidmain(String[] args) {
Randomrandom=newRandom();
intn=random.nextInt(128);//0 ~127之间的整数,包含最大值和最小值
if(n>=48&&n<=57){
System.out.println("随机到一个数字"+ (char)n);
}elseif (n>=65&&n<=90){
System.out.println("随机到一个大写字母"+ (char)n);
}elseif (n>=97&&n<=122){
System.out.println("随机到一个小写字母"+ (char)n);
}else{
System.out.println("随机到一个其他字符"+ (char)n);
}
}
}
switch
package com.softeem.fz;
import java.util.Scanner;
/*
switch里面的条件表达式是一个值
语法:
给一个条件值;
switch(条件表达式){
case 值1;
语句1;
break;//将程序停止的关键字
case 值2;
语句 2;
break;
case 值3;
break;
...
default;
语句 n;
break;
}
执行过程;
如果条件表达式的值和case候命的值相同,就选择相应的语句进行执行
执行完成执行break将条件语句停止
如果忘写break会出现case穿透
case后面可以是哪些值>
基本数据类型:byte short char int
基本数据类型的封装类型:Byte Short Character Integer
枚举类型:enum
字符串类型:String(jdk1.7之后支持)
* */
public class Demo_04 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个月份");
int month = sc.nextInt();
switch(month){
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;
case 8:
System.out.println("巨冷");
break;
case 9:
System.out.println("巨冷");
break;
case 10:
System.out.println("巨冷");
break;
case 11:
System.out.println("巨冷");
break;
case 12:
System.out.println("巨冷");
break;
}
}
}练习
使用if语句执行输入一个月份,判断这个月份属于哪个季节
package com.j2301.fz;
import java.util.Scanner;
/**
*
* 使用if语句执行输入一个月份,判断这个月份属于哪个季节
*/
public class Demo_05 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个月份:");
int month = scanner.nextInt();
if(month == 3 || month == 4 || month == 5){
System.out.println("春暖花开");
}else if(month == 6 || month == 7 || month == 8){
System.out.println("夏日炎炎");
}else if(month == 9 || month == 10 || month == 11){
System.out.println("秋高气爽");
}else if(month == 12 || month == 1 || month == 2){
System.out.println("白雪皑皑");
}else{
System.out.println("你是外星人吧,月份都搞不明白");
}
}
}做一个简单的计算器
使用分支做一个简单的计算器,要求输入两个数,并且输入运算符,计算输出两个数的值
package com.j2301.fz;
import java.util.Scanner;
/**
* 1、使用分支做一个简单的计算器,要求输入两个数,并且输入运算符,计算输出两个数的值
*/
public class Demo_06 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入第一个数:");
double num1 = scanner.nextDouble();
System.out.println("请输入一个运算符(1:+、2:-、3:*、4:/ ):");
String m = scanner.next();
System.out.println("请输入第二个数:");
double num2 = scanner.nextDouble();
if(m.equals("+")){
System.out.println(num1 + " + " + num2 + " = " + (num1 + num2));
}else if(m.equals("-")){
System.out.println(num1 + " - " + num2 + " = " + (num1 - num2));
}else if(m.equals("*")){
System.out.println(num1 + " * " + num2 + " = " + (num1 * num2));
}else if(m.equals("/")){
if(num2 != 0){
System.out.println(num1 + " / " + num2 + " = " + (num1 / num2));
}else{
System.out.println("除数不能为0");
}
}else{
System.out.println("其他的运算程序员正在开发,敬请期待");
}
System.out.println("===================================================");
switch (m) {
case "+":
System.out.println(num1 + " + " + num2 + " = " + (num1 + num2));
break;
case "-":
System.out.println(num1 + " - " + num2 + " = " + (num1 - num2));
break;
case "*":
System.out.println(num1 + " * " + num2 + " = " + (num1 * num2));
break;
case "/":
System.out.println(num1 + " / " + num2 + " = " + (num1 / num2));
break;
default:
System.out.println("其他的运算程序员正在开发,敬请期待");
break;
}
}
}用switch语句对程序进行成绩的分级处理
package com.j2301.fz;
import java.util.Scanner;
/**
* 2、假如现在要使用switch语句对程序进行成绩的分级处理
* 【100 ~ 90】优秀
* 【89 ~ 80】良好
* 【79 ~ 70】中等
* 【69 ~ 60】及格
* 【59 ~ 0】不及格
* 如果用户输入的信息不在这个范围之内要进行提示
* 成绩可以是double类型
*/
public class Demo_07 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的成绩:");
double s = scanner.nextDouble();
int m = (int)s;//97.5 --> 97 ---> 97 / 10 = 9
if(m <= 100 && m >= 0){
switch (m / 10){
case 10:
case 9:
System.out.println("小伙子你很优秀");
break;
case 8:
System.out.println("哎呦,不错哦");
break;
case 7:
System.out.println("还需要努力吖");
break;
case 6:
System.out.println("每天的作业好好做了么?拿来我看看");
break;
default:
System.out.println("下课到办公室,咱们聊聊");
break;
}
}else{
System.out.println("你输入的成绩有误请重新输入");
}
}
}Day_04 循环
一.死循环
没有停止条件死循环我们要避免,一般用在我们不知道程序执行多少次的情况下我们使用死循环的时候,一般要是有分支语句
Demo_07(死循环)
packagecom.softeem.xh;
/*
死循环
没有停止条件
死循环我们要避免,一般用在我们不知道程序执行多少次的情况下
我们使用死循环的时候,一般要是有分支语句
*
* */
publicclassDemo_07 {
publicstaticvoidmain(String[] args) {
/*for (;;){
System.out.println("for循环的死循环");
}*/
/*for (int i = 0 ;;i++){
System.out.println("i = " + i);
}*/
System.out.println("死循环");
}
}
二.截断循环
break:当一层循环结束循环,当有两层循环的时候,结束内循环continue: 跳过循环,然后再执行一次,continue并不会把循环终止掉
Demo_08(截断循环)
packagecom.softeem.xh;
/*截断循环
break:当一层循环结束循环,当有两层循环的时候,结束内循环
continue: 跳过循环,然后再执行一次,continue并不会把循环终止掉
* */
publicclassDemo_08 {
publicstaticvoidmain(String[] args) {
for (inti=0 ;i<10 ;i++ ){
if (i==5){
/* System.out.println("i = " + i);*/
continue;
}else {
System.out.println("i = "+i);
}
}
}
}三.while循环
语法:
初始化条件表达式; while(条件表达式){ 循环体; 控制条件表达式; }
执行过程:
初始化条件表达式,确定程序从什么时候开始执行,只执行一次
执行条件表达式进行判断,如果为true 就执行语句,false就不执行
执行循环体
执行控制条件表达式对条件作出改变
回到第二步
While_01(while循环)
packagecom.softeem.xh;
/*
while 循环
语法:
初始化条件表达式;
while(条件表达式){
循环体;
控制条件表达式;
}
执行过程:
1.初始化条件表达式,确定程序从什么时候开始执行,只执行一次
2.执行条件表达式进行判断,如果为true 就执行语句,false就不执行
3.执行循环体
4.执行控制条件表达式对条件作出改变
5.回到第二步
* */
publicclassWhile_01 {
publicstaticvoidmain(String[] args) {
inti=0;
while(i<5){
System.out.println("i = "+i);
i++;
}
}
}
四.do while 循环
语法;
初始化条件表达式;
do{ 循环体; 控制条件表达式;}while(条件表达式);
执行过程:
执行初始化条件表达式,控制程序从什么时候开始执行
执行循环体
执行控制条件表达式
执行条件表达式进行判断,如果是true就继续执行第二步,如果是false,就不执行
特点:
无论是否符合条件都至少执行一次,先执行后面改变条件之后再判断
Dowhile_01(do while循环)
packagecom.softeem.xh;
/*
do while 循环
语法;
初始化条件表达式;
do{
循环体;
控制条件表达式;
}while(条件表达式);
执行过程:
1.执行初始化条件表达式,控制程序从什么时候开始执行
2.执行循环体
3.执行控制条件表达式
4.执行条件表达式进行判断,如果是true就继续执行第二步,如果是false,就不执行
特点:无论是否符合条件都至少执行一次,先执行后面改变条件之后再判断
* */
publicclassDowhile_01 {
publicstaticvoidmain(String[] args) {
inti=10;
do {
System.out.println("i = "+i);
i++;
System.out.println("i======"+i);
}while(i<10);
}
}
五.for循环
循环
给程序一个初始值,给定一个判断条件,如果符合条件就执行,每次执行完毕后, 对程序下次执行的条件作出改变,如果不符合就不执行
语法:
for(初始化条件表达式; 条件表达式; 控制条件表达式){ 程序执行的循环内容 }
初始化条件表达式:定义程序从什么时候开始执行
条件表达式:程序在什么条件下结束
循环内容;程序执行的主要内容
控制条件表达式:对程序执行的条件进行更改
执行过程:
执行初始化条件表达式,控制条件开始执行的内容,在这里一般都是定义一个开始变量,并且只执行一次
执行条件表达式,如果条件表达式符合,就执行循环内容,不符合就结束循环
执行循环的主要内容,可以定义变量,可以是分支语句,可以是输入,随机数...
执行控制条件表达式,对程序下一次执行的内容进行修改
回到第二步
从现在开始,我们接触的是算法和逻辑
写题的时候注意思路,一步步分析,一步步完成写代码一定要写
代码是自己写的
for_01(for循环)
packagecom.softeem.xh;
/*
循环
给程序一个初始值,给定一个判断条件,如果符合条件就执行,每次执行完毕后,
对程序下次执行的条件作出改变,如果不符合就不执行
语法:
for(初始化条件表达式; 条件表达式; 控制条件表达式){
程序执行的循环内容
}
初始化条件表达式:定义程序从什么时候开始执行
条件表达式:程序在什么条件下结束
循环内容;程序执行的主要内容
控制条件表达式:对程序执行的条件进行更改
.
-
执行过程:
1.执行初始化条件表达式,控制条件开始执行的内容,在这里一般都是定义一个开始变量,并且只执行一次
2.执行条件表达式,如果条件表达式符合,就执行循环内容,不符合就结束循环
3.执行循环的主要内容,可以定义变量,可以是分支语句,可以是输入,随机数...
4.执行控制条件表达式,对程序下一次执行的内容进行修改
5.回到第二步
从现在开始,我们接触的是算法和逻辑
写题的时候注意思路,一步步分析,一步步完成
写代码一定要写
代码是自己写的
*
* */
publicclassfor_01 {
publicstaticvoidmain(String[] args) {
//要求打印出200以内的偶数
//初始化条件表达 ; 条件表达式 ;控制条件表达式
for(inti=0 ; i<=200 ; i+=2 ){
System.out.println(i);
}
System.out.println("=================");
for (inti=0; i<=200 ; i++){
//做判断
if (i%2==0 ) {
System.out.println(i);
}
}
}
}
Day_05 数组
一.嵌套循环
Demo_01(九九乘法表)
packagecom.softeem.xh;
/*
九九乘法表
一共九行九列,
每行的元素个数,行数是有关系的
元素的个数根据行数依次增加
*
* */
publicclassDemo_01 {
publicstaticvoidmain(String[] args) {
//因为一个语句块中不能出现相同名字的变量
//外层循环,控制行数
//初始化条件表达式,程序从什么时候开始 1
//条件表达式:程序到什么时候结束 9
//控制条件表达式:程序做什么改变 +1
for (inti=1 ; i<9 ;i++) {
//内层循环控制每行打印的个数
//初始化条件表达式: 1
//条件表达式: 每行打印的行数等于个数
//控制条件表达式: +1
for (intj=1; j<=i ;j++){//j 每行打印的个数
System.out.print(j+"×"+i+"="+i*j+"\t");
}
System.out.println("\n");
}
}
}
Demo_02(100以内质数)
packagecom.softeem.xh;
/*
打印100以内的质数
只能被1 和 它本身整除的数,就叫质数
比如: 5 ,只能被 1 和 5 整除
25 能够 被 1 5 25 整除,这个数就不是质数,叫和数
判断质数的思想;
从 2 到n-1之间的元素和n进行求余运算,如果n被整除了,没有余数了,就不是质数
如果一直有余数,那么这个数就是质数
* */
publicclassDemo_02 {
publicstaticvoidmain(String[] args) {
/*1.确定循环的变量
循环从什么时候开始执行? 2
循环从什么时候停止? 100
每次做什么样的改变? +1
* */
for (inti= 2 ; i<=100 ; i++){//负责对我们需要进行是否是质数的元素进行判断
//默认所有的数都是质数,然后拿2 - n-1 之间的元素和 n 进行求余运算
//如果某一个元素除尽了,那么就说明这个数不是质数,就将这个标准改为false
//定义一个标识,用来标志所有数是质数
//
booleanflag=true;//保证每个数的标识都是质数
/*求余运算的循环
从什么时候开始执行? j = 2
到什么时候结束? i <= i-1结束
每次做什么样的改变? j++*/
for (intj=2; j<i ; i++){
if (i%j==0){
flag=false;
}
}
if (flag){
System.out.println(" i = "+i);
}
}
/*for (int i = 2 ; i <=100;i++){
boolean flag = true;
for (int j =2 ; j < i ; j++){
if (i %j == 0 ){
flag = false;
}
}
if (flag){
System.out.println("i = " + i);
}
}*/
}
}Demo_03(优化代码,增加算力)
Math.sqrt(被开方数)//对数组进行开方
packagecom.softeem.xh;
/*
代码优化,增加算力
* */
publicclassDemo_03 {
publicstaticvoidmain(String[] args) {
intindex=0;
for (inti=2 ; i<=1000000000;i++){
booleanflag=true;
// 对数据进行开方处理
for (intj=2 ; j<=Math.sqrt(i) ; j++){
if (i%j==0 ){
flag=false;
break;
}
}
if (flag){
index++;
}
}
System.out.println("一共有"+index+"个质数" );
}
}
二.数组
数组:array
在计算机的内容中开辟 连续的内存空间,用来储存元素的 集合
数组中存储的元素的数据类型是相同的,由定义的时候的数组的数据类型决定
数组中存储元素的时候如果使用动态初始化,我们只能存储止指定的个数,如果想要存储更多, 就要手动扩容,重新定义一个数组,将原来数组中的元素储存到新的数组中
动态初始化:
我们定义了数组,但是没有忘数组中存储元素,现在元素已经有了,我们所有的空间都赋了初始值 数据类型[] 数组名 = new 数据类型[数组长度或者元素个数]
不同数据类型的初始值:
数据类型 初始值 byte short intlong 0 float double 0.0 char /u0000 boolean false String null
静态初始化
当我们定义数组的时候,直接给定数组中的元素,存储了多少元素,数组的长度就是几
数据类型[] 数组名 = new 数据类型[] {元素1,元素2,元素3...}
数据类型[] 数组名 = {元素1,元素2,元素3...}
获取数组元素
如何获取数组长度:数组.length
如何获取数组中的元素:数组名[数组元素下标] : 数组元素的下标是从0 开始的
如何给数组中的元素进行赋值:数组名[数组下标] = 赋值;
Demo_01(数组定义)
packagearr;
/*
数组:
array
在计算机的内容中开辟 连续的内存空间,用来储存元素的 集合
1.数组中存储的元素的数据类型是相同的,由定义的时候的数组的数据类型决定
2.数组中存储元素的时候如果使用动态初始化,我们只能存储止指定的个数,如果想要存储更多,
就要手动扩容,重新定义一个数组,将原来数组中的元素储存到新的数组中
动态初始化:
我们定义了数组,但是没有忘数组中存储元素,现在元素已经有了,我们所有的空间都赋了初始值
数据类型[] 数组名 = new 数据类型[数组长度或者元素个数]
不同数据类型的初始值:
数据类型 初始值
byte short intlong 0
float double 0.0
char /u0000
boolean false
String null
静态初始化
当我们定义数组的时候,直接给定数组中的元素,存储了多少元素,数组的长度就是几
1.数据类型[] 数组名 = new 数据类型[] {元素1,元素2,元素3...}
2.数据类型[] 数组名 = {元素1,元素2,元素3...}
如何获取数组长度:数组.length
如何获取数组中的元素:数组名[数组元素下标] : 数组元素的下标是从0 开始的
如何给数组中的元素进行赋值:数组名[数组下标] = 赋值;
* */
publicclassDemo_01 {
publicstaticvoidmain(String[] args) {
//动态初始化:
//数据类型[] 数组名 = new 数据类型[数组长度或者元素个数]
//定义了一个int类型的数组,数组长度是5
int[] arr=newint[5];//[0,0,0,0,]
arr[3] =100;//[0,0,100,0,]
//静态初始化
//数据类型[] 数组名 = new 数据类型[] {元素1,元素2,元素3...}
String[] name=newString[]{"佛耶戈","希瓦娜","奥利安娜","马尔扎哈","伊泽瑞尔"};
System.out.println(name[2]);
//数据类型[] 数组名 = {元素1,元素2,元素3...}
double[] price= {39.9 ,69.9,9.9,89.9,288};
//如何获取数组长度: 数组名.length
intlen=name.length;//length是一个属性,因为后面没有加括号
System.out.println("数组在内存中的地址: "+name);//[Ljava.lang.String;@6aaa5eb0
System.out.println("name的长度是: "+name );//[Ljava.lang.String;@6aaa5eb0
Strings="圣诞节卡加斯科技馆";
System.out.println("字符串的长度: "+s.length());//9
}
}
Demo_02(遍历 && 异常 && foreach)
foreach:增强for循环 我们可以获取到元素,不能获取到下标,但是可以自动对数组遍历赋值给变量
ArrayIndexOutOfBoundsException：抛出异常表示使用非法索引访问数组,索引为负数或者大于等于数组的大小
数组遍历(将数组中的元素,一个个取出来)
packagearr;
importjava.util.Arrays;
/*
ArrayIndexOutOfBoundsException：抛出异常表示使用非法索引访问数组,索引为负数或者大于等于数组的大小
数组遍历(将数组中的元素,一个个取出来)
* */
publicclassDemo_02 {
publicstaticvoidmain(String[] args) {
String[] name= {"佛耶戈","希瓦娜","奥利安娜","马尔扎哈","伊泽瑞尔"};
// System.out.println(name[5]); //ArrayIndexOutOfBoundsException
//for循环
//1.初始化条件表达式:从数组下标0开始
//2.条件表达式:到数组长度 - 1结束
//3.控制条件表达式:每次元素加1处理
for(inti=0; i<name.length; i++){//元素下标
System.out.print(name[i] +"\t");
}
System.out.println();
System.out.println(" ============================ ");
//foreach:增强for循环 我们可以获取到元素,不能获取到下标,但是可以自动对数组遍历赋值给变量
/**
* 语法:
* for(数据类型 变量名 : 数组名){
* 对变量进行处理;
* }
*/
for(Stringn : name){
System.out.print(n+"\t");
}
System.out.println();
System.out.println(" ============================ ");
//使用了java内置类Arrays中的toString方法将数组中的元素内容以字符串形式输出
System.out.println(Arrays.toString(name));
}
}
Demo_03(100~200内质数存入数组)
packagearr;
importjava.util.Arrays;
//3.将100 - 200 之间的质数找出来，存储到一个数组中
// 1.先进行质数的个数判断,然后存储到一个变量中
/* 2.新建一个数组,然后将累加的数组的元素个数作为数组的长度
3.在执行一次质数的处理然后将质数存进去
1.首先定义一个长度超过预期值的数组,
2.然后查找所有的质数并且对数组中的元素进行赋值
3.将数组中不为零的元素,放在一个新的数组中
* */
publicclassDemo_05 {
publicstaticvoidmain(String[] args) {
//定义一个长度为100的数组,用来存储质数
intarr[] =newint[100];
intindex=0;//定义一个变量,作为数组的下标
//查找范围内的质数,并且将其放在数组中
//外层循环定义我们要判断的数值有哪些
for(inti=100 ; i<=200 ;i++){//i表示,我们要遍历多少个数值
//给元素定义一个标识,默认他为质数,如果他不是质数,就将这个数的标识改变
booleanflag=true;
//拿2到i的开平方之间的元素和 i 进行求余运算,如果余数不为0了
//说明这个数有别的因数,不是一个质数,将标识改为false
for (intj=2 ;j<=Math.sqrt(i);i++){//j表示有多少数值要和i 进行求余运算
if(i%j==0){
flag=false;//改变标识符
break;//将内循环结束
}
}
//判断这个标识有没有被改变,如果没有改变就将这个数放在数组中
if (flag=true){
arr[index] =i;
index++;//当一个数存进去之后,我们要对数组中的元素下标进行累加处理
}
}
System.out.println(Arrays.toString(arr));
int[] array=newint[index];//将上面累加的质数的个数作为新数组的长度
index=0 ;//重新初始化计数器,然后对array进行赋值
for (inti=0 ; i<arr.length;i++ ){
if (arr[i] !=0){
array[index] =arr[i];//将存放质数和0的数组中的质数赋值到新数组中
index++;//每放一个元素就将新数组下标移动到下一位
}
}
System.out.println(Arrays.toString(array));
}
}Demo_04(数组商品购买)
packagearr;
importjava.util.Scanner;
/*
定义三个数组
商品名称:[巧克力,牛奶,瓜子,花生,八宝粥,可乐,雪碧,辣条]
商品价格:[8 5 6 7 4 3 3 5 ]
商品库存:[100 20 40 50 80 30 70 80]
*模拟用户购买商品的过程
*1、首先向用户显示有什么商品
*2、问用户需要什么
*3、判断是否有
*4、有的话告诉用户多少钱要多少,没有的话告诉用户出门左转隔壁看看
* 5、用户输入购买量之后判断库存是否充足王
*6、如果充足可以实现购买,如果不足，去隔壁看看
* 7、打印用户购买的数量和价格以及总价
* */
publicclassDemo_06 {
publicstaticvoidmain(String[] args) {
Stringgoods[] = {"巧克力","牛奶","瓜子","花生","八宝粥","可乐","雪碧","辣条"};
intmoney[] = {8 , 5 , 6 , 7 , 4 ,3 , 3 , 5 };
intdepot[] = {100 , 20 ,40 , 50 , 80 , 30 , 70 , 80};
System.out.println("我们这里售卖巧克力,牛奶,瓜子,花生,八宝粥,可乐,雪碧,辣条,请问您要购买什么商品");
Scannersc=newScanner(System.in);
Stringsay1=sc.next();//接收顾客购买的商品信息
intindex1=0;//判断第商品所在数组的位置
booleanflag=false;
for (inti=0 ; i<goods.length;i++){
if (say1.equals(goods[i])){
flag=true;
index1=i;
break;
}
}
if (flag){//判断购买商品是否有售
System.out.println("本店有售"+say1+"商品价格为"+money[index1]+"元");
}else{
System.out.println("本店无售"+say1+",请出门左转隔壁看看");
}
}
}三.冒泡排序
冒泡排序:
元素之间两比较,如果前面的数比后面的数大,两个数据就交换位置,然后拿着较大的数和下一个数进行比较每次比较找出本轮的最大值,每轮的最大值不参与下一轮比较
Demo_01(冒泡排序)
packagearr;
importjava.util.Arrays;
/*
冒泡排序:
元素之间两比较,如果前面的数比后面的数大,两个数据就交换位置,然后拿着较大的数和下一个数进行比较
每次比较找出本轮的最大值,每轮的最大值不参与下一轮比较
* */
publicclassMaopao {
publicstaticvoidmain(String[] args) {
intarr[] ={68,55,79,32,11,77,89,45,99,12};
//外层循环表示比较的轮数,因为最后一轮剩下一个数据可,自己不需要和自己比较
for (inti=0; i<arr.length-1;i++){
//内层循环,控制每轮比较的次数是自己本身数组长度减一
for (intj=0; j<arr.length-i-1 ;j++){
if (arr[j] >arr[j+1]){
intnum1=arr[j+1];//小的腾出来
arr[j+1] =arr[j];//大的放后面
arr[j] =num1;//小的放前面
}
}
}
System.out.println(Arrays.toString(arr));
}
}四.排序
Demo_01(排序)
package arr;
import java.util.Arrays;
//排序
public class SortDemo {
public static void main(String[] args) {
int arr[] = {68,55,79,32,11,77,89,45,99,12};
System.out.println("原始数组: " + Arrays.toString(arr));
Arrays.sort(arr);
System.out.println("排序数组: " + Arrays.toString(arr));
}
}
2440
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
