黑马程序员—Java基础知识

---------------------- JavaEE+Android、Java培训、期待与您交流！ ----------------------

java中的名称规范

包名：多单词组成时所有字母都小写，xxxyyyzzz

类名接口名：多单词组成时，所有单词的首字母大写，XxxYyyZzz

变量名和函数名：多单词组成时，第一个单词首字母小写，第二 个单词开始每个单词首字母大写，xxxYyyZzz

常量名：所有字母都大写，XXXYYYZZZ

Java中的注释

单行注释——格式：//注释文字 多行注释——格式：/*
注释文字*/文档注释——格式：/** 注释文字*/

小的语法知识点

①，默认数据类型：整数——int int型变量默认初始值为0

小数——doubledouble型变量默认初始值为0.0

boolean数据类型默认初始值为false，引用数据类型默认初始值为full

②，求余运算：1%5=11%-5=1
-1%5=-1

③，转义字符：“\n”——换行“\b”——退格“\t”——制表符“\r”——回车键（Window系统中回车键为：\r\n）

④，&与&&，| 与 ||的区别：前者符号两边都参与运算，后者是选择运算

⑤，自动类型转换关系：byte -->short(char) -->int -->long -->float -->double

⑥，异或（ ^）：6
^ 3 = 5。一个数异或同一个数两次，那么结果还为本身。在加密和解密中有应

⑦，>>与>>>的区别：对于>>，最高位补什么由原有数据的最高位值而定，若最高位为0，右移后，用0补空位。如果最高位为1，右移后，用1补空位。对于>>>，无论最高位是0还是1，右移后，都用0补空位

⑧，对两个变量进行互换（不需要第三方变量）：n=m+n; m=n-m; n=n-m; 或 n=n^m; m=n^m; n=n^m;

⑨，三元运算符与if…else…的区别：三元运算符必须返回一个值

⑩，if 和switch语句很像，具体什么时候该用哪个语句呢？

如果判断的具体值不多，而符合byte，short，int，char这四种类型，建议用switch，效率高；对于双区间判断，结果为boolean类型建议使用 if 语句，适用范围光。

无限循环的最简单表示形式：for( ; ; ) ;默认循环条件为truewhile(true) ;

标号：可以让循环跳出到指定位置

十进制数转换为任意进制数

看下面代码：

<span style="font-family:Arial;font-size:12px;">/**
需求|：定义一个方法，使其可将十进制转换为二进制、八进制及十六进制
思路|：查表法|：
1定义一个表，存放十六进制的所有元素，此表也就包含了二进制和八进制的元素
2通过十进制&15（或7，或1）的运算，得到进制最后一位数，倒序存入数组
3然后移位（>>>4或3或1），得到一个新数
4重复此过程，知道数值为零，结束
5将数组打印
*/
import java.util.*;
class Trans
{
public static int scan()
{
Scanner in = new Scanner(System.in);
System.out.print("请输入十进制数字：");
int num = in.nextInt();
return num;
}
public static void trans(int num,int base,int offset)
{
if(num ==0)
{
System.out.println("\n转换后的数为：" + 0);
return ;
}
StringBuffer sa = new StringBuffer();
char[] ch =  {  '0','1','2','3',
'4','5','6','7',
'8','9','A','B',
'C','D','E','F'};
char[] arr = new char[32];
int pos = arr.length;
while(num!=0)
{
int temp = num & base;
arr[--pos] = ch[temp];
num >>>=offset;
}

for(int i=pos;i<arr.length;i++)
{
sa.append(arr[i]);
}
System.out.println("后的数为：" + sa);
}
//转换为二进制
public static void toBin(int num)
{
System.out.print("转换成二进制");
trans(num,1,1);
}
//转换为八进制
public static void toBa(int num)
{
System.out.print("转换成八进制");
trans(num,7,3);
}
//转换为十六进制
public static void toHex(int num)
{
System.out.print("转换成十六进制");
trans(num,15,4);
}
public static void main(String [] args)
{
int x = 0;
x = scan();
toBin(x);
toBa(x);
toHex(x);
}
}</span>

内存管理

Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据处理方式和内存管理方式

栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放。

堆内存：数组和对象，通过new建立的实例都存放在堆内存中；每一个实体都有内存地址值；实体中的变量都有默认初始化值；实体不在被使用，会在不确定的时间内被垃圾回收器回收。

数组

定义：同一种类型数据的集合。其实数组就是一个容器

数组定义的格式：

一维数组： int[] x ; int x[] ;

二维数组：int[][] x ; int x[][] ;int[] x[] ;

例如：int[] x,y[]表示定义了两个数组，x是一维的，y是二维的

数组操作常见的问题：

数组脚标越界异常(ArrayIndexOutOfBoundsException)；.空指针异常(NullPointerException)；

数组工具类

/**
这是一个可以对数组进行操作的工具类，该类中提供了获取数组中最值和对数组进行排序的功能！
@author 土豆
@version V1.1
*/
public class ArrayTool
{
private ArrayTool(){}
/**
获取整形数组中的最大值
@param arr 接受一个int类型的数组
@retutn 返回数组中的最大值
*/
public static int getMax(int[] arr)			//获取最大值
{
int max=0;
for(int i=0;i<arr.length;i++)
{
if(arr[max]<arr[i])
max=i;
}
return arr[max];
}
/**
获取整形数组中的最小值
@param arr 接受一个int类型的数组
@retutn 返回数组中的最小值
*/
public static int getMin(int[] arr)			//获取最小值
{
int min=0;
for(int i=0;i<arr.length;i++)
{
if(arr[min]>arr[i])
min=i;
}
return arr[min];
}
/**
用选择法对数组进行排序
@param arr 接受一个int类型的数组
*/
public static void selectSort(int[] arr)		//对数组进行排序
{
for(int i=0;i<arr.length-1;i++)
for(int j=i+1;j<arr.length;j++)
{
if(arr[i]>arr[j])
swap(arr,i,j);
}
}
/**
用冒泡法对数组进行排序
@param arr 接受一个int类型的数组
*/
public static void bubbleSort(int[] arr)
{
for(int i=0;i<arr.length-1;i++)
for(int j=0;j<arr.length-i-1;j++)
{
if(arr[j]<arr[j+1])
swap(arr,i,j);
}
}
/**
给数组元素进行位置置换
@param arr 接受一个int类型的数组
@param a 要置换的位置
@param b 要置换的位置
*/
private static void swap(int[] arr,int a,int b)
{
int temp=arr[a];
arr[a]=arr;
arr[b]=temp;
}
/**
打印数组中的元素，打印格式是：[elment,elment,……]
@param arr 接受一个int类型的数组
*/
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.println(arr[i]+"]");
}
}
}

[b]数组中元素的查找

<span style="font-family:Arial;font-size:12px;">/**需求|：查找数组中的元素
思路|：遍历数组中的元素，并与要查找的内容比较，相同，则返回脚标
步骤
1创建类FindArry
2用for遍历数组，如果查找到相同内容，记录脚标并返回
3如果未找到，就返回-1

如果要在一个有序数组中插入一个数，之后仍有序
就是先查找数组，用折中法：如果查找到有此数，则返回的中间值就是插入的地方，否则将返回的-1改成返回min，即为插入的地方
如：{1, 2, 3, 5, 6, 8, 11, 13}插入8，返回mid = 5；插入后为{1, 2, 3, 5, 6, 8, 8, 11, 13}
插入10，返回min = 6，插入后为{1, 2, 3, 5, 6, 8, 10, 11, 13}
*/

import java.util.*;
class FindArry
{
//方法一：遍历每一个元素查找
public static int findarr(int[] arr,int key)
{
for(int i=0;i<arr.length;i++)
{
if(arr[i] == key)
{
return i;
}
}
return -1;
}

//方法二：折半，前提是数组是按大小顺序排列好的，
//用查找的值和中间值比较，大则和下一半中间值比依次，小则和上一半中间值比，找到则返回。
//        小值的编号在左移或大值的编号在右移。要判断是否大小值的编号相遇，仍若未找到，则不再循环，返回-1
public static int FindArry1(int[] arr,int key)
{
int min,max,mid;
min = 0;
max = arr.length-1;
mid = (min + max)/2;

//循环，查找中间值与要查找的值比较
while(key != arr[mid])
{
if (key > arr[mid])
min = mid +1;
else
max = mid - 1;
if (min > max)
return -1;
mid = (min + max)/2;
}
return mid;
}

//方法三：折半第二种
//while的条件改变
public static int FindArry2(int[] arr,int key)
{
int min,max,mid;
min = 0;
max = arr.length-1;

//循环，查找中间值与要查找的值比较
while(min <= max)
{
mid = (min + max)>>1;
if (key > arr[mid])
min = mid +1;
else if(key<arr[mid])
max = mid - 1;
else
return mid;
}
return -1;
}

public static void main(String [] args)
{
int[] arr = {1,6,11,2,8,5,3,13};
int m = findarr(arr,3);
System.out.println("m=" + m);
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
int x = FindArry1(arr,13);
int y = FindArry2(arr,25);
System.out.println("查找13的结果x=" + x + "\n查找25的结果y=" + y);
}
}</span>

---------------------- JavaEE+Android、Java培训、期待与您交流！ ----------------------
详细请查看： http://edu.csdn.net