java 基础语法自己总结

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