------- android培训、java培训、期待与您交流！ ----------
负数的二进制表现形式就是讲二进制的1变成0，将0变成1，然后再加一
负数的最高位都是1
变量，开辟内存空间，变量名，变量类型，就是通过明确数据类型，变量名称数据来完成
定义变量数据类型变量名=初始化值 int x=4;当数据不确定的时候，需要对数据存储时，就定义一个变量来完成存储动作
Systerm.out println(b)
字符串数据和任何数据使用+都是相连接，最终都会变成字符串
通过\来转变后面字母或者符号的含义
\n:换行
\b:退格
\r:按下回车键。window系统，回车符是由两个字符来表示\r\n
\t:制表符，相当于tab键
环境变量的配置，Path 首先查找的是当前目录，classpath首先查找的是配置的变量
标示符有字母，数字和下划线组成，数字不可以开头，不可使用关键字
java严格区分大小写
包名，所有字母小写
类名和接口名，所有单词首字母大写
变量名和函数名，多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写
常量名，所有字母都大写
\运算符，左边小于右边，结果是左边，左边等于右边结果是0，右边是1，结果是0.运算时出现负数时，只看左边，结果的正负与左边保持一致
字符串和任何数据使用+都是相连接，最终都会变成字符串。
+=,-=,*=,/=,%=
x+=4相当于x=x+4;
^ 异或，两边相同结果是假，两边不同结果是真
&&只要左边是假的，右边就不进行运算了，直接判断为假
&无论左边的真假，右边依然进行运算 ||与|雷同
位运算，是二进制运算3<<2
左移其实就是该数乘以2的所移数位的次方
右移就是该数除以2的所移位数的次方
右移后最高位要补的数要看原来的数的最高位，最高位是1，就补1，如果用>>>右移，最高位都用0补。
一个数异或同一个数两次结果还是那个数
if else 结构简写格式：变量=（条件表达式）？表达式1：表达式2；
三元运算符 好处：可以简化if else代码；
弊端：因为是运算符，所以运算完必须要有一个结果，而if else可以运算完不要结果。
swith语句只有四种类型的数据：byte，short，int，char
在swith语句中，case是没有顺序的，default可以在任何地方，但程序都会先判断case，在判断default
执行到break或到}时结束
如果case或default后面没有break，则将相面的所有语句执行一遍，直到遇到break或}
if和swith语句很像，如果判断的具体数值不多，而且符合byte，short，int，char这四种类型，虽然两种语句都可以使用，但swith效率较高；其他情况，对区间判断，对结果为boolean类型判断，if语句效率较高
continue 作用为结束本次循环，继续下次循环
break和continue作用的范围；break和continue单独存在时，下面可以有任何语句，因为都执行不到
定义一个函数，首先明确该函数的运算结果是什么类型，其次是明确在定义该功能的过程中是否需要未知的内容参与运算
尽量不要定义含有输出语句等操作的函数，函数只负责返回操作后的值，至于操作后怎样处理返回值是调用者的事
函数重载，区分两个函数的是参数的个数和类型
当定义的功能相同，但参与运算的未知内容不同，这时就定义一个函数名称以表示其功能，方便阅读，而通过参数列表的不同来区分同名函数
重载和函数的返回类型没有关系
注意参数的顺序
数组是引用数据类型，两个变量可以指向同一个实体
java程序运行时，系统会开辟五块内存空间
栈内存 数据使用完毕会自动释放
堆内存 堆内存里的每个实体都有一个存放位置，内存地址值；对内存中的实体是用于封装数据的，而实体中的实体都有默认值，int 默认0；double 默认0.0；float默认0.0f；boolean默认false；垃圾回收
方法区
本地方法区
寄存器
（定义在方法里的变量，方法参数里的变量，for循环的变量都是局部变量）局部变量都在栈内存里，new出来的实体都存在堆里。例如int[] x=new int[3];系统在栈内存中存x，而在堆内存中存放实体数组，在栈内存中x只是记录了或者指向了该内存在堆内存中的首地址，如果x=null，则x将指向空，不再指向该内存地址。
当一个实体在堆内存中没有任何引用时，则视为垃圾，系统不会立刻清除，而java会不定时的启动垃圾回收机制，将该实体清除。这也是java对c++的优化
基础部分联系代码
class ArrayTest1
{
public static void main(String[] args)
{
int[] arr=new int[]{5,9,14,23,8,6,33,3,24,7};
int[] ar=new int[]{12,3,45,6,8,31,13,9};
printArray(arr);
selectSort(arr);
System.out.print("排序后的数组为：");
printArray(arr);
printArray(ar);
maopaoSort(ar);
System.out.print("排序后的数组为：");
printArray(ar);
}
public static void printArray(int[] arr)
{
System.out.print("[");
for (int i=0;i<arr.length ;i++ )
{
if (i!=arr.length-1)
{
System.out.print(arr[i]+",");
}
else
{
System.out.print(arr[i]);
}
}
System.out.println("]");
}
//选择排序：内循环结束一次，最值出现在头角标位置上
public static void selectSort(int[] arr)
{
for (int i=0;i<arr.length-1 ; i++)//最后一个数不用再和后面的数进行比较，所以减1
{
for (int j=i+1;j<arr.length ;j++ )
{
if (arr[i]>arr[j])
{
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
return ;
}
//冒泡排序，相邻的两个元素进行比较，如果符合条件则换位
public static void maopaoSort(int[] arr)
{
for (int i=0;i<arr.length-1 ;i++ )
{
for (int j=0;j<arr.length-i-1 ; j++)//-i是为了让每次比较的次数减一，-1是为了角标不超出范围；
{
if (arr[j]>arr[j+1])
{
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
return ;
}
}
class ArrayTest2
{
public static void main(String[] args)
{
int[] arr ={1,2,3,4,5,6,7,8,9,10};
int index = getIndex(arr,7);
System.out.println("index="+index);
int index_1 = halfSearch(arr,5);
System.out.println("index_1="+index_1);
int index_2=halfSearch_2(arr,12);
System.out.println("index_2="+index_2);
}
//定义功能，获取key第一次出现在数组中的位置，如果返回时-1，那么说明该key在数组中不存在；
public static int getIndex(int[] arr,int key)
{
for (int i=0;i<arr.length ;i++ )
{
if (arr[i]==key)
return i;
}
return -1;
}
/*
折半查找可以提高效率，必须保证该数组是有序的。
*/
public static int halfSearch(int[] arr,int key)
{
int min,max,mid;
min = 0;
max = arr.length-1;
mid = (max+min)/2;
while (arr[mid]!=key)
{
if (key>arr[mid])
min = mid + 1;
else if (key<arr[mid])
max = mid - 1;
if (min>max)
return -1;
mid = (max+min)/2;
}
return mid;
}
public static int halfSearch_2(int[] arr,int key)
{
int min=0,max=arr.length-1,mid;
while (min<max)
{
mid=(max+min)/2;
if (key>arr[mid])
min=mid+1;
else if (key<arr[mid])
max=mid-1;
else
return mid;
}
return -1;
}
}
class ArrayTest3
{
public static void main(String[] args)
{
toBin(10);
System.out.println(Integer.toBinaryString(60));
toHex(60);
toHex_1(60);
System.out.println();
toBin_1(-60);
}
//十进制-->二进制
public static void toBin(int num)
{
StringBuffer sb=new StringBuffer();//定义一个可以存数的容器
while (num>0)
{
sb.append(num%2);
num=num/2;
}
System.out.println(sb.reverse());//该方法有可以反转的功能；
}
//十进制-->十六进制
public static void toHex(int num )
{
StringBuffer sb=new StringBuffer();
for (int i=0;i<8;i++)
{
int temp=num & 15;
if(temp>9)
//System.out.println((char)(temp-10+'A'));
sb.append((char)(temp-10+'A'));
else
//System.out.println(temp);
sb.append(temp);
num = num >>> 4;
}
System.out.println(sb.reverse());
}
/*查表法，将所有的元素临时存储起来，建立对应关系。
每次&15后的值作为索引去查建立好的表，就可以找到相应的元素
这样比-10+’A‘要简单
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
0 1 2 3 4 5 6 7 8 9 A B C D E F
可以通过数组的形式来定义该表
*/
public static void toHex_1(int num)
{
//StringBuffer sb=new StringBuffer();
char[] chs = {'0','1','2','3','4','5','6','7','8','9',
'A','B','C','D','E','F'};
//不通过stringbuffer的reverse功能，而可以通过数组来完成存储和反转功能
char[] arr=new char[8];
int pos=arr.length;//定义一个指针，为了使结果为正方向，指针指向数组的最后，即完成结果的倒着存
while(num!=0)//当num为0时，表示要操作的数以没有了有效位，循环结束，这里用while可以避免像for循环那样遍历所有32位
{
int temp=num & 15;
//char temp_1 = chs[temp];
arr[--pos]=chs[temp];//将对应表数组的下角标为temp的值赋给数组arr
//sb.append(temp_1);
num = num >>> 4;
}
//System.out.println(sb.reverse());
for (int i=pos;i<arr.length ;i++)//只从arr的指针位开始遍历输出，这里是正着输出
{
System.out.print(arr[i]+" ");
}
}
//查表法定义的十进制转二进制。查表法比较通用，进制间转换都可类比的写出来，而且查表法还可对负数进行转换，而上面的方法由于有num>0这一限制条件，无法转换负数
public static void toBin_1(int num)
{
char[] chs={'0','1'};
char[] arr=new char[32];
int pos=arr.length;
while (num!=0)
{
int temp=num & 1;
arr[--pos]=chs[temp];
num=num>>>1;
}
for (int i=pos;i<arr.length ;i++ )
{
System.out.print(arr[i]);
}
}
}
------- android培训、java培训、期待与您交流！ ----------
421
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
