黑马程序员_基础复习一(数组、排序、面向对象)

----------------------------android培训、java培训、期待与您交流！----------------------------------

 

感想：

 

1. 这几天学习了毕老师的基础视频中的：数组、排序、查找、进制转换、面对对象的概念部分，虽然在上学的时候学习过java，但是仍然受益匪浅，学到了很多细节的东西。

1. 要学到新的知识要先把”自己的瓶子倒空“，这样才能更好的获取新的知识，虚心接受。

擦缺补漏：

• 栈内存：

数据使用完成后，会自动释放。

• 静态代码块：

随着类的加载而执行，只执行一次，用于给类进行初始化。

• 构造代码块：

用于给对象初始化。

• Person p = new Person("dupengtao",23);该句话都做了什么？

1）因为new用到了Person.class 所以会先找到Person.class文件并加载到内存中。

2）执行该类中的static代码块，如果有的话，给Person.class类进行初始化。

3）在堆内存中开辟空间，分配内存地址。

4）在堆内存中建立对象的特有属性、并进行默认初始化。

5）对属性进行显示初始化。

6）对对象进行构造代码块初始化。

7）对对象进行对应的构造函数初始化。

8）将内存地址付给栈内存中的P变量。

• 单例模式三部曲：

1）将构造函数私有化。

2）在类中创建一个个本类对象。

3）提供一个可以获取到该对象的方法。

/*
这个是先初始化对象。
称为：饿汉式。

Single类一进内存，就已经创建好了对象。
class Single
{
	private static Single s = new Single();
	private Single(){}
	public static Single getInstance()
	{
		return s;
	}
}
*/

//对象是方法被调用时，才初始化，也叫做对象的延时加载。成为：懒汉式。
//Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。
class Single
{
	private static Single s = null;
	private Single(){}
	public static Single getInstance()
	{
		if(s==null)
		{
			synchronized(Single.class)
			{				
				if(s==null)
					s = new Single();
			}
		}
		return s;
	}
}

//记录原则：定义单例，建议使用饿汉式。

class  
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}

 

• 十进制转换到十六进制

public static void toHex(int num) {
		StringBuffer sb = new StringBuffer();
		for (int x = 0; x < 8; x++) {
			int temp = num & 15;
			if (temp > 9) {
				sb.append((char) (temp - 10 + 'A'));
			} else {
				sb.append(temp);
			}
			num = num >>> 4;
		}
		System.out.println(sb.reverse());

	}

 

编码：

1.ASCII码表：

键盘上所有的键都对应一个字符，每个字符都对应一个码值

ASCII编码的文件，每个字符占1个字节

有一个特殊的键"Enter",对应两个字符回车换行(\r\n)

2.gb2312码表： 兼容了一个ASC码表

英文占1个字节，是一个正数

中文占两个字节，两个都是负数

3.gbk码表： 升级

英文占1个字节，是一个正数

中文占两个字节，第一个是负数，第二个可正可负

4.unicode码表：国际码表

所有的字符都占两个字节，

        前两个字节为特征码

5.UTF-8码表： 国际码表

每个字符占1~3个字节，实验证明，英文占1个，汉字占三个

前三个字节为特征码

位运算符

&: 任何数与0&结果都为0，与1&结果为自身

|：任何数与1|结果都为1，与0|结果为自身

^: 任何数与一个指定的数异或两次，其结果为自身(可用于加密文件)

<<: 左移，高位抛弃，低位补0，   01101110 <<2  --> 10111000

>>: 右移，低位抛弃，高位补什么看符号位  10110111 >> 3 --> 11110110

>>>: 无符号右移，低位抛弃，高位补0，不考虑符号 10110111 >>> 3 --> 00010110

>>>:无无符号右移       将二进制的每一位向右移，高位补0。正数移动没区别，负数移动后变为正数。

内存结构

Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，有对空间进行了不同区域

的划分，因为每一片区域都有特定的处理数据方式和内 存管理方式。

栈内存

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

堆内存

• l         数组和对象，通过new建立的实例都存放在堆内存中。

• l         每一个实体都有内存地址值

• l         实体中的变量都有默认初始化值

• l         实体不在被使用，会在不确定的时间内被垃圾回收器回收

方法区，本地方法区，寄存器

最后附上各种排序的效率测试：

 public static void bubbleSort(int a[]) {
int len = a.length;
for (int i = 0; i < len - 1; i++) {
for (int j = 0; j < len - 1 - i; j++) {
if (a[j] > a[j + 1]) {
int temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
}
public static void selectSort(int a[]) {
int temp = 0;
int len = a.length;
for (int i = 0; i < len - 1; i++) {
int min = a[i];
int index = i;
for (int j = i + 1; j < len; j++) {
if (min > a[j]) {
min = a[j];
index = j;
}
}
temp = a[i];
a[i] = a[index];
a[index] = temp;
}
}
public static void insertSort(int a[]) {
int len = a.length;
for (int i = 1; i < len; i++) {
int temp = a[i];// 待插入的值
int index = i;// 待插入的位置
while (index > 0 && a[index - 1] > temp) {
a[index] = a[index - 1];// 待插入的位置重新赋更大的值
index--;// 位置往前移
}
a[index] = temp;
}
}
public static int partition(int a[], int low, int height) {
int key = a[low];
while (low < height) {
while (low < height && a[height] >= key)
height--;
a[low] = a[height];
while (low < height && a[low] <= key)
low++;
a[height] = a[low];
}
a[low] = key;
return low;
}
public static void quickSort(int a[], int low, int height) {
if (low < height) {
int result = partition(a, low, height);
quickSort(a, low, result - 1);
quickSort(a, result + 1, height);
}
}
测试结果
------------------------------------------
测试数据10000
冒泡排序：120ms
选择排序：32ms
插入排序：20ms
快速排序：7ms
------------------------------------------
测试数据100000
冒泡排序：13098ms
选择排序：2334ms
插入排序：1264ms
快速排序：23ms
效率差距很大啊！！！！

 

----------------------------android培训、java培训、期待与您交流！----------------------------------

·