Java数据类型:
基本数据类型 数值型 整数类型<默认int> byte short int long
浮点类型<默认double> float<加F f 4字节> double<8个字节>
字符类型 char<表示单个字符 \t \n Unicode> 多个字符用String
布尔型 bolean<true false 不能取null>
引用数据类型 类 class
接口 interface
数组[]
整数类型 java整型默认为int声明long需加l或L
byte 一字节 8bit<位 -128 ~127> short 2字节 int 4字节 long 8字节
变量之间的运算
1.自动类型转换
容量小转到容量大的 char,byte,short>int>long>float>double
char 字符对应一个数字
注:char,byte,short之间转换都是int
2.强制类型转换
大-小
注.精度损失
3.字符串与基本数据类型转换<+连接运算>结果为一个字符串
不同进制的转换
二进制:0,1 以0b或0B开头
十进制:0-9 满10进1
八进制:0-7 满8进1,以数字0开头表示
十六进制:0-9及A-F,满16进1,以0x或OX表示
此处A-F不区分大小写
原码 反码<各个位除符取反> 补码<反码+1 不管整数 负数.以补码存储>
运算符 + - * / % ++ -- +<>
1.% 结果的符号取决于被模数 如:int i1=-12%5 =-2
2.前++ 后++ 运行前后自加1
3.''+''
是做 字符运算。得到Unicode码相加
赋值运算符: += -= *= /= %= =:赋值<==等号>
比较运算符: == != < > <= >= instanceof:检查是否是类的对象如:"Hello" instanceof String trie
switch
1.变量可以存放
<char byte short int 枚举 String(sdk1.7 - myeclipse 集成的是1.6)>
2.break 跳出
3.default:d佛的 可选.位置灵活
4.case :ks 只能是值.不能是取值范围
逻辑运算符:
&逻辑与 &&短语与<并且> |逻辑或<XXXX> || 段路或 !逻辑非< ^逻辑异或>
&与&&的区别
& 不管左端是true还是false,右端都会进行运行
&& 当左端为false是.右端不在运行<两端都为false时两端才有区别>
|与||区别
|当左端为true 右端照样运行
||当左端为true时,右端不在运行<两端为true才有区别>
位运算符:<< >> >>>:无符号 | & ^ ~:反码
//60 手动的方式,从控制台输出60的16进制
int i=60;
String er=Integer.toBinaryString(i);//得到二进制
String shi=Integer.toHexString(i);//十 3c
三元运算符:
(条件表达式)？表达式1<为true> :表达式2<false>
要求:1.表达式1与表达式2为同种类型
<竟然为运算符,就一定有运算结果,结果的数据类型与1,2的类型一致>
int i=20; int j=30;
String str=(i>j)?:"i大" :(i==j)?"相等":"j大";
注：运算符的优先级
程序流程控制:
1.顺序结构:程序从上往下运行
2.分支结构:if else ,switch
<if else 无论后面多少条件满足,只运行第一个> else if 也是如此
用=赋值.赋值下面输出的语句不执行
3.循环结构:while,do while for
获取键盘相关的东西: Scanner s=new Scanner(System.in);
String str=s.next();//从键盘获取一个字符串
switch case :
大于60输出合格.不是反之. 100/10
方法1.score/10 case :10 及格.....<case相同的输出语句可以只留一个.输出>
2.score/60
键盘上输入2014年的month月和day天.输出输入2014年的第几天
1.用Scanner 输入 s.nextInt接收.在用一个变量接收输入的值.
通过switch case判断 case不写break. <先得到每月的总天数,看日历.如输入6.4 case ：6 接收的变量 num+=30 后面的写break.一直执行下去 后面的54321 月>
循环结构:
for
1.
1-100的值.每个三的倍数打上3foo 5的倍数打上5的倍数biz 7的倍数打上baz
如:1 2 3foo 4 5biz 6foo 7baz 15foo biz 105 foo biz baz
注: if()else if() 满足第一个.第二个也满足.只运行第一个
for(i=1;i<=150;i++){
if(i%3==0) System.out.print("foo");//不换行输出 println换行
if(i%5==0) System.out.print("foo");
if(i%7==0) System.out.print("foo");
}
2.三位数.其各位上数字立方和等于其本身.153=1*1*1+3*3*3+*5*5*5
for(int 1=100;i<=1000;i++){
int s1=i/100;//百位
int s2=i/10;//十位
int s2=i%10;//个位
if(i==s1*s1*s1+i==s2*s2*s2+i==s3*s3*s3){
输出
}
}
while :
int i=1;
int num=0;
while(i<=100){
if(i%2==0){
System.out.println("100偶数"+i)
num+=i;
}
i++;
}
System.out.println("100偶和"+i)
do while:
int i=1;
do{
if(i%2==0){
system.out.println(i);
}
i++;
}while(i<=100);
do while 与while 的区别:与for区别 for <i在里面> while在外面
do:至少执行一次
练习:从键盘读入个数不确定的整数,
并判断读入的正数和负数的个数,输入为0时结束
1.<从键盘读入10个数不确定的整数,并判断读入的正数和负数的个数>
Scanner s=new Scanner(System.in);
int a=0;//正个数
int b=0;//负个数
for(i=0; i<10;i++){
System.out.println("第"+(i+1)+"个数")
int num=s.nextInt();
if(num>0){
a++;
}else if(num<0){
b++;
}
}
System.out.println("正"+a);
System.out.println("负"+b);
2.从键盘读入个数不确定的整数,
并判断读入的正数和负数的个数,输入为0时结束
for(;;){//无限循环 -- while(true){
System.out.pringln("输入");
int num=s.nextInt();
if(num>0)a++;
else if(num<0)b++;
else break;//输入0的时候 这里可以用break
}
System.out.println("正"+a);
System.out.println("负"+b);
while: while(true){}//无限循环
题:输出直角三角形 *
for(int j=0;j<4;j++){//外层循环控制行数
for(int i=0;i<j+1;i++){//内层循环列数
*
}
}
//0<1 - (0<1 1<1 2<1 3<1 4<1)*
//0<2 -(0<2 1<2 2<2 3<2 4<2) **
//0<3 -(0<3 1<3 2<3 3<3 4<3) ***
题:
*****
****
***
**
*
for(int j=0;j<5;j++){//外层循环控制行数
for(int i=0;i<5-j;i++){// for int i=j;j<5;i++
*
}
}
0<5-1 -从0开始的。 0:1
题：
*
**
***
****
*****
****
***
**
*
上面两个for放在一起 哦了
题:
*
* *//到五 菱形
*
i k- j* k=4-i j=i+1
0 4 1
1 3 2
2 2 3
3 1 4
4 0 5
//上
for(int i=0; i<5;i++){
for(int k=0; k<4-i;k++){
System.out.print("-");
}
for(j=1;j<i+1;j++){
System.out.print("* ");
}
System.out.println();
}
//下
i k- j* k=i+1 j=4-i
0 1 4
1 2 3
2 3 2
3 4 1
for(i=0;i<4;i++){
for(int k=0;k<i+1;k++){
-
}
for(int j=0;j<4-i;j++){
(* );
}
}
题:实现九九乘法表
for(i=1;i<=9;i++){//一共有9行
for(int j=1;j<=i;j++){//每行有i个等式
System.out.print(i+"*"+j+"="+i*j+"\t");
}
}
看： 1： 1*1 2<=1 不等于>
2: 1*2 2*2 <2 小于等于2>
题：输出一到100的质数 2
<100以内的所有质数>
1.
boolean flag=false;
long start=System.currentTimeMillis();//获取当前系统的毫秒数
for(int i=2;i<=100000;i++){// l:for 标签
//判断i是否为一个质数
for(int j=2;j<i;j++){
if(i%j==0){
flag=true;
//continue l;
System.out.println(i);
}
}
if(!flag){
System.out.println(i);
}
flag=false;
//注： 2不进第二个if 3也不进 4进了flag=false 变成true了.进了把变量从新给为true
long end=System.currentTimeMillis();
System.out.println("所花费的时间:"+(end-start));//35535 35秒
}
//3 不进
//4 进 2<4 2%4==0 后面j++ <还是判断3<4不进if?无视这个>
2.第一种 话费时间35秒 .优化 时间
if(i%j==0){
flag=true;
break;
}
时间:10059 10秒
3.再次优化.《不让if输出》 //2473 两秒
第二个 for j<maht.sqrt(i) //36毫秒
break与continue的区别
break:使用的地方. switch case 。 或者循环中.表示：结束当前循环
continue：柯提牛 使用在循环结构中. 表示结束当次循环
注意: 在break和continue 后面不能写语句永远不能执行.<break后面加了编译都不通过 contrnue 可以通过但不也是不执行的>
代码看区别:
for(i=1;i<=10;i++){ //label:for
if(i%4==0){
break;//123 //break label;- 使用标签
continue;//123567910 //continue label 不输出下面的println();
}
sy i;
}
题：
一个数恰好是因子之和.成为完数.因子.这个数本身正的约数。如6=1+2+3
int luis=0;
for(int i=1;i<=1000;i++){ //1-1000的遍历
for(int j=1;j<i;j++){//每执行完一下。将I的所有因子累加到luis中
if(i%j==0){
luis+=j;
}
}
if(i==luis){
syst:i;
}
luis=0;//从新给0
}
数组:
1.定义数组
String[] luis;
2.初始化
//1.静态初始化 <初始化数组与给数组元素赋值同时进行
luis =new String[]{"heihei","哈哈","呵呵"};
int[] scores;
//2.动态初始化 <分开进行
scores =new int[4];
3.调用相应的数组的元素
//下标从0开始 到数组的长度结束 或 -1结束
scores[0] =60;
scores[1] =60;
scores[3] =60;
//数组的长度, length
//遍历
for(int i=0; i<luis.length;i++){
System.out.println(luis[i]);
}
//对于基于基本数据类型的变量创建的数组:byte short int long float double char boolean
//1.对于 byte short int long 而言.创建数组以后默认值为0
int[] scores=new int[4];
scores[0]=89;
scores[3]=89;//输出结果 89 0 0 89 --byte也是一样
//2.对于float double而言默认值是0.0
//3.对于char而言 默认为空格 " "空
//4.对于boolean false
基本属性定义未赋值默认值为以上
//5.对于引用类型的变量构成的数组而言.默认初始化值为null.如String
//关于数组存储结构
栈:stack <存放:区部变量,对象的引用>
堆:heap <存放new 出来的东西>
方法区 <方法<常量池>>
静态域
注:栈地址引用堆.在改变默认值
//写法
1.int[] myint={11,12,14};
2.int[] myint2;
myint2=new int[]{11,12,14};
注.数组一旦初始化,其长度是不可变的
2.定义类.包含三个属性.学好 年纪 成绩 创建20个学生对象学号1-20 年级成绩随机数确定 打印3年级的学生信息
生成随机数:Math.random(), 返回值类型double
四舍五入取整:Maht.round(double d),返回值类型long
3.从键盘读入学生成绩,找出最高分.并输出学生成绩等级,
1.成绩>=最高分-10 等级为a
1.成绩>=最高分-20 等级为b
1.成绩>=最高分-30 等级为c
1.成绩>=最高分-40 等级为d
<1.创建Scanner的对象,并从键盘获取学生个数N
2.根据输入的学生个数,创建一个长度为N的数组长度
3.依次从键盘获取N个学生成绩,赋给数组.-获取N个学生成绩的最高分
4.遍历学生成绩的数组.根据学生成绩与最高分的差值,赋予相应的等级.并输出
1.
Scanner s=new Scanner(System.in);
System.out.println("输入学生个数");
int count=s.nextInt();//学生的个数
2.
int[] scores=new int[count];
int maxScore=0;//比较记录
System.out.println("输入"+count+"个成绩");
3.
for(int i=0;i<scores.length;i++){
//
scores[i];
int score=s.nextInt();//依次从键盘获取学生的成绩
scores[i]=score;//把成绩赋给数组
if(scores[i]>maxScore){
maxScore=scores[i];
}
}
4.
System.out.println("最高分多少"+maxScore);
for(int i=0; i<scores.length;i++){
char level;
if(scores[i]>=maxScores-10){
level='A';
}else if(scores[i]>=maxScores-20){
level='B';
}else if(scores[i]>=maxScores-30){
level='C';
}else{
level='D';
}// 注.if else if 只进一个满足的. 就算满足两个或者.第三个.都只进第一个.
System.out.println("Student"+i+"score is"+scores[i]+"grade"+level);
}
二维数组.
注:二维数组的以为.int是引用类型所以默认类型是null.到第二维int 默认才是0
如:int[] [] i=new int[3];
i[0]=new int[3];
i[1]=new int[2];
i[2]=new int[4];
i[1][0]=90;
i[2][1]=100;
题:算出数组当中的和
int[][] m=new int[][]{{1,1,1},{1,1},{9,5,5}};
int num=0;
for(int i=0;i<m.length;i++){
for(int j=0;j<m[i].length;j++){//m[i] 第二维数组的长度
System.out.print(m[i][j]+"\t");
num +=m[i][j]; //m[i][j] 只写成m[j] m 找不到哪个的第二维数组
}
System.out.println();
}
System.out.println(num);
// 特殊写法:
//int[] x,y[]; x是一维数组 y 是二维
//int[] x;一维
//int[] y[];二维
y=new int[3] [2];
x=y[0];//y[0]:1一维 两边都是int 都是一维
x[0]=y[1];//这样不行.y[1]这样对应的是一维数组. 而x[0]:是x数组中的某一个值.二者不对应//改成x[0] =y[1][0];
//1.x[0]=y;//no
//2.y[0]=x;//yes
//3.y[0][0]=x;//no
//4.x[0][0]=y;//no
//5.y[0][0]=x[0];//yes
//6.x=y;//no
写法:
1. int[] x,y[];
2. int[]x 或者int x[]一维;
3. int[][]y 或者int[] y[] 或者 int 有[][] 二维
数组异常:
1.下标越界
java.lang.ArrayIndexOutOfBoundsException
如:
for(int m=0;m<i.length;m++){//对的
System.out.println(i[m]);
}
for(int m=0;m<=i.length;m++){//下标是从0开始
System.out.println(i[m]);
}
2.空指针异常
NullPointerException
//第一种
boolean[] b=new boolean[3];
b=null;//b引用类型是null b索引找不到吧[0]
System.out.println(b[0]);
//第二种
String[] str=new String[4];
//str[3] =new String("AA"); //str[3]="AA";
System.out.println(str[3].toString());//空<字符串的对象>对象点方法也报空指针的错
//第三种
int[][] k=new int[3][];
j[3][0]=12;
题:使用二维数组打印一个10行的杨辉三角
1
11
121
1331
14641
15101051
...
提示: 头尾1 10=上面的4+6
1.第一行有1个元素,第n行有n个元素
2.每一行的第一个元素和最后一个元素都是1
3.从第三个开始,对于非第一个元素和最后一个元素的元素
yanghui[i][j]=yanghui[i-1][j-1]+yanghui[i-1][j];
//
int[][] yanghui=new int[10][];
//1.初始化二维代码
for(int i=0;i<yanghui.length.length;i++){
yanghui[i]=new int[i+1];//第一行1 第二行11
}
//2.显示的为二维数组的每个元素赋值
for(i=0;i<yanghui.lenght;i++){
for(j=0;i<yanghui[i].length;j++){
yanghui[i][0]=yanghui[i][i]=1;//头尾1 1
if(i>1 && j>0 && j<1){
yanghui[i][j]=yanghui[i-1][j]+yanghui[i-1][j-1];//列 i-1 +行j-1==就是结果
}
}
}
数组算法:
1.求数组元素的最大值.最小值.平均值.总和
2.数组的复制.反转
3.数组元素的排序
一：
int[] arr=new int[]{112,-1,29,30,200,2};
//最大值
max =arr[0];//不定为0的原因是.可能数组里为负数.arr[0]，数组的第一个元素
for(int i=0;i<arr.length;i++){
if(i<arr[i]){
max =arr[i];
}
}
int min=arr[0];
//最小值 if(i>arr[i])
//总和
int sum=0;
for{
sum+=arr[i];
}
int avg=0;
avg=sum/arr.length;
二:
数组的复制和反转
题:
声明int[] array1和array2两个变量.
使用{} 把array{2,3,5,7,11,13,17,19};
显示arry1的内容
1.赋值array2变量等于array1,--2.复制array1给array2
修改array2中的偶搜索引元素.使其等于索引值
如:array[0]=0,array2[2]=2 -打印array1
int[] array1,array2;
array1=new int[]{2,4,5,8,11,13,30,20};
//for 遍历
//赋值array2变量等于array1,
//1.
array2=array1;
//2.
array2=new int[array1.length];
//修改array2 一
for(int i=0;i<array1.length;i++){
//1.
if(i%2==0){
array2[i]=i;
}
}
//for 遍历输出 2 //2.复制 二
for(int i=0;i<array2.length;i++){
//1.
if(i%2==0){
array2[i]=i;
}else{
array[i]=array1[i]; 复制1给2
}
}
结果: 注意:! array2=array1; //赋值到是索引地址.操作的还是同一个数组
1.2 3 5 7 11 13 17 19
2.0 3 2 7 4 13 6 19
1.2 3 5 7 11 13 17 19
数组的复制:
int[] arr1=new int[arr.length]
for(int i=0;i<arr1.length;i++){
arr1[i]=arr[i];
}
三：数组的反转
//1
for(int i=0;i<arr.length/2;i++){
int temp=arr[i];
arr[i]=arr[arr.length-1-i];//0.0 没懂
arr[arr.length-1-i]=temp;
}
//2
for(int x=0;y=arr.length-1;x<y;x++;y--){
int temp=arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
数组排序
1.插入排序
直接插入排序.折半插入排序,Shell排序
2.交换排序
冒泡排序,快速排序(或分区交换排序)
3.选择排序
简单选择排序,堆排序
4.归并排序
桶试排序
5.基数排序
1.冒泡 小倒大 . 从小到大。 依次得到最大的
for(int i=0;i<arr.length-1;i++){//多少轮比较
for(int j=0;i<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
2.直接选择排序 小倒大
for(int i=0;i<arr.length-1;i++){
for(int j=i;j<arr.length;j++){
if(arr[i]>arr[j]){
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
//2 方法2 效率提升.先直接找出最小的哪个值
for(int i=0;i<arr.length-1;i++){
int w=i;
for(int j=i;j<arr.length;j++){
if(arr[t]>arr[j]){
t=j;
}
}
if(arr[i]>arr[j]){
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
//java 封装好的排序
Arrays.sort(arr);ss