黑马程序员_Java基础知识

时间：2022-07-07 20:00:47
-------   android培训 、 java培训 、期待与您交流！ ----------
一、java对内存的划分：
1. 寄存器：
  主要是*处理器内的组成部分，是一个容量很小的且高速的存贮部件，用来暂存指令、数据和地址。
2. 本地方法区：   
3. 方法区：
  对于被装载的每个类，虚拟机都会把这个类的类型信息存储在方法区，方法区中存储有一下信息：
  (1).类的全限定名；
  (2).类的超类的全限定名；
  (3).这个类是类类型还是接口类型；
  (4).类的访问修饰符；
  (5).超接口的权限定名的有序类表；
  (6).该类的常量池，该类所有常量的一个有序集合，包括直接类型和其他类的字段和方法的符号引用；
  (7).字段信息，字段名，字段类型，字段的修饰符；
  (8).方法信息，方法名，返回值类型，方法的修饰符，如果一个方法不是抽象的和本地的还将保存方法的字节码，操作数栈和方法的栈帧中的局部变量的大小，异常表；
  (9).除了常量意外的所有类变量，类变量是所有类实例共享的，但是没有类实例也可以访问，只与类有关，编译时常量；
  (10).一个到classLoader(类的加载器)的应用；
  (11).一个到class的引用；
  (12).方法表(为了尽可能的土改访问效率，大部分虚拟机对每个装载的非抽象类，都申城了方发表，把他们当做类型信息放在方法区了)，方法区同样是可以被回收的。
4. 桟内存：
  存储的都是局部变量
  而且变量所属的作用域一旦结束，该变量就会自动的释放。

5. 堆内存：
  存储的是数组和对象(其实数组就是对象)凡是new建立在堆中。
  特点：
  (1). 每一个实体都有首地址值。
  (2). 堆内存中的每一个变量都有默认初始化值，根据类型的不同而不同。整数是0，小数0.0或者0.0f,boolean类型的是使false char默认是 '\u0000'
  (3). 垃圾回收机制。

二、java中的运算符：
1. 比较运算：比较运算符运算的结果必须是boolean型，必须是true或者false.
System.out.println(3>2);
2. 逻辑运算符，运算完成的结果是boolean型
&：与
|：或
&运算的特点：
true & true = true
true & false= false
false& true = false
false&false = false

&运算规律：两边都是true的时候结果才是true，两边之中要是有一个是false那么结果必须是false
int x = 3;
System.out.println(x>2 & x<5);   

|运算符的特点：
true | true = true
true |false = true
false| true = true
false|false = false

|运算规律：两边之中要是有一个是true，则运算之后的结果是true，要是两个同时为true(false),运算结果是true(false)。
int x = 3;
System.out.println(x>2 | x<5);

^:运算的特点：
true ^ true = false
true ^false = true
false^ true = true
false^false = false

^运算的规律：两边要是相同的话，结果是false，两边不相同的时候就是true。

int x = 8;
System.out.println(x<1 ^ x>78); false
System.out.println(x<1 ^ x<78); true

3.     &和&&的区别和联系：
(1). 这两者的左右两边都是boolean类型。
(2). &的左边为false时，还要对右边进行判断。而&&的左边为false时，右边的不用进行判断。
(3). &用于位运算。

4. |和||的区别和联系：
(1). |和||的左右两边都要使用boolean类型。
(2). |的左边为true时，还要对右边进行判断。而||的左边为true时，右边的表达式将不再进行运算。
(3). |用于位运算。
！：取事物的反面。

三、java数组中的常用方法：
1. 数组中最大值的获取：
方式一：记住数组中的一个元素的值，然后在此值的基础上和其他的元素进行比较得出数组中的最大值
 
	public static int getMax(int[] arr){

		int max = arr[0];
		for(int x=1; x<arr.length; x++){
			if(arr[x]>max)
				max = arr[x];
		}
		return max;
	}
方式二：也是使用数组中的一个元素，这次是记录住这个元素的角标值的索引 
	public static int getMax2(int[] arr)
	{
		int maxIndex = 0;
		for(int x=1; x<arr.length; x++){
			if(arr[x]>arr[maxIndex])
				maxIndex = x;
		}
		return arr[maxIndex];
	}
        2.     数组的一些排序方法：
选择排序：选择排序的思想是使用第一个元素和其他后边的元素进行比较，如果比较的结果是前边的元素大于后边的元素
则进行交换，以此比较交换到最后一个元素，这样的结果就得到了第一个元素是最小的元素了。然后在进行第二个元素的
同样方法比较，直到最后的一个元素为止。


int[] arr = new int[]{23, 45, 165, 98, 20,12, 78};  //也可以使用后边的方式进行定义： int[] arr = {23, 45, 165, 98, 20,12, 78};  
int arr[] = {23, 45, 165, 98, 20,12, 78}; 这种方式和C中的数组定义方式是相同的。
常用方法一：选择排序
public static void selectSort(int[] arr){

for(int x=0; x<arr.length-1; x++){

for(int y=x+1; y<arr.length; y++){
if(arr[x]>arr[y]){

int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
}
优化以上选择排序方法：(超级选择排序法，效率比上边的那个要高)
public static void selectSort(int[] arr)
{
for(int x=0; x<arr.length-1; x++)
{
int value = arr[x];
int index = x;

for(int y=x+1; y<arr.length; y++)
{
if(value>arr[y])
{
value = arr[y];
index = y;
}
}
if(index!=x)
{
int temp = arr[x];
arr[x] = arr[index];
arr[index] = temp;
}
}
}
常用方法二：冒泡排序
思想：交换相邻两个元素，逐次的排出数组的最大值，次大值......最后是最小值。
算法的基本过程：第一趟，比较相邻的两个元素，如果前边的大于后边的元素的话，进行交换，总共比较的次数是总元素的次数减一；
第二趟，和第一趟中的方法相同，比较相邻两个元素的大小，若符合条件，然后进行调换位置，总共比较的次数比上次次数减少一次；
.....
public static void bubbleSort(int[] arr)
{
for(int x=0; x<arr.length-1; x++)
{
for(int y=0; y<arr.length-x-1; y++)
{
if(arr[y] > arr[y+1])
{
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}
}


数组中元素的查找方法：
普通的查找方法，效率比较低，查找的数组不需要是有序的。使用的范围较广。
思想：遍历数组，在便利数组的过程中查找相同的元素。
public static int search(int[] arr, int key){

for(int x=0; x<arr.length; x++){

if(arr[x] == key)
return x;
}
return -1;
}


二分法查找(折半查找法)
注意：二分法查找元素的时候数组一定要是有序元素，否则查找失败！
public static int halfSearch(int[] arr, int key){

int max,min,mid;
max = arr.length-1;
min = 0;
mid = (min+max)/2;


while(arr[mid]!=key){

if(key>arr[mid])
min = mid+1;
else if(key<arr[mid])
max = mid-1;

if(max<min)
return -1;


mid = (max+min)/2;


}
return mid;
}


折半查找方式二：
public static int halfSearch2(int[] arr, int key)
{
int max,min,mid;
max = arr.length-1;
min = 0;
while(max>min)
{
mid = (max+min)>>2; //使用位运算效率很高。


if(key>arr[mid])
min = mid + 1;
else if(key<arr[mid])
max = mid - 1;
else 
return mid;
}
return -1;
}
进制转换的相关的知识以及所要知道的一些知识重点：以下讲解是以十六进制为例，当我们将一个整数转换成十六进制的首先要对整数进行处理，
十六进制就是使用四个二进制位表示一个十六进制数，比如60的二进制表现形式如下：
00000000 00000000 00000000 00111100  -->60
&       00000000 00000000 00000000 00001111  -->15      下一步
-----------------------------------------------------   ======> 将60右移4位(使用无符号>>>比较好)
00000000 00000000 00000000 00001100  -->12


00000000 00000000 00000000 00000011  -->3
&       00000000 00000000 00000000 00001111  -->15      
-----------------------------------------------------   ======> 对结果进行查表得出大于数字9以后的字母表现形式。
00000000 00000000 00000000 00000011  -->3

经过以上的分析过程可以知道，当我们从十进制转十六进制的时候，先对这个数 & 15，然后再右移4位，直到这个数为0为止。
那么转八进制也是同样的道理，当我们从十进制转成八进制的时候，先对这个数 & 7 ，然后再右移3位，直到这个数为0为止。
那么转二进制也是同样的道理，当我们从十进制转成二进制的时候，先对这个数 & 1 ，然后再右移1位，直到这个数为0为止。
将得到的结果存储到一个临时的容器中，然后变成一个字符串输出。
3.  进制转换： 
  /**
	* 进制转换：将一个整数转换成其他进制的表现形式
	* 参数1：要转换的参数
	* 参数2：要进行&运算的模值
	* 参数3：要移动的位置
	*/
	public static String int2Other(int num, int model, int offset)
	{
		if(num==0){
			return "0";
		}

		char[] arr = {'0','1','2','3',
			      '4','5','6','7',
			      '8','9','A','B',
			      'C','D','E','F'};
		
		char[] chs = new char[8];

		int pos = chs.length;
	
		while(num!=0){
		
			int temp = num & model;
			chs[--pos] = arr[temp];
			num = num>>>offset;
		}
		// 使用字符串形式进行返回
		String str = new String(chs, pos, chs.length-pos);
		
		return str;
	}
       /*
	* 方法：十进制转成二进制
	*/
	public static String toBinaryString(int i)
	{
		return int2Other(i, 1, 1);
	}
	
       /*
	* 方法：十进制转换成八进制
	*/
	public static String toOctalString(int i)
	{
		return int2Other(i, 7, 3);
	}

       /*
	* 方法：十进制转换成十六进制数
	*/
	public static String toHexString(int i)
	{
		return int2Other(i, 15, 4);
	}

 -------  Windows Phone 7手机开发、 .Net培训、期待与您交流！ -------


标签：

相关文章