Java基础（3）-内部类，包装类和基本类型，数组，基础排序介绍

1.内部类

在一个类里面定义另一个内部类；
内部类首先能够直接调用外部类各个属性（包括私有属性，但是外部类无法访问内部类内部属性）；
其次相同包里面的类无法直接访问使用该内部类；
分为匿名内部类（一般用于在在监听器中个，比如键盘监听），成员内部类，局部内部类（定义在方法里面）；
成员内部类分为非静态内部类和静态内部类（由static 修饰）；
匿名内部类结构：
new 父类构造器（实参）接口（）{
类体
}
在文件格式下，外部类与内部类用$ 隔开；比如在类Person中创建一个内部类Per，则文件下它的名字是Person$per;
静态内部类无法使用外部类的普通属性，只能使用静态属性；
成员内部类：

 public class Outer {
	public static void main(String[] args) {
		Face.Nose n = new Face().new Nose();//实例化内部类
		n.breath();//调用内部类的方法；
		Face.Ear e = new Face.Ear();//与上面的非静态内部类进行比较，发现还是有很大的不同的；
		e.listen();
	}
}

class Face {
	int type = 4;
    String nose = "sdd"
	class Nose {//非静态内部类；
		String nose = "鼻子";

		void breath() {
			System.out.println(type);//内部类可以直接使用外部类的属性；
			System.out.println(Face.this.nose);//如果外部类和内部类属性名一致则必须要指明是那个的属性；
			System.out.println("呼吸");
		}
	}
	static class Ear {
		void listen() {
//			System.out.println(type);//这个由于在外部类中，type不属于静态属性所以，在静态内部类中无法调用；
			System.out.println("听力");
		}
	}
}

2.字符串

Java中的字符串就是Unicode字符序列；Java中没有内置的字符串类型，而是在标准Java类库中提供了一个预定义的类String，每一个用双引号引起来的就是字符串； String是不可变字符序列，因为在String类中，它的值是由final修饰的；

public class Mytest {
	public static void main(String[] args) {
		String str = "abc";//放在常量池
		String str1 = "abc";
		String str2 = new String("abcd");
		String str3 = new String("abcd");
		System.out.println(str.equals(str1));//这里比较了它的值；true
		System.out.println(str==str1);//因为这里只比较了他的对象；true
		System.out.println(str2.equals(str3));//true
		System.out.println(str2==str3);//这里只比较的是它的对象；false
	}
}

至于在String类中自带的方法之类的下次看了源码之后再说；

indexOf(String)：返回这个字符所在的位置（第一个字符的位置）;
lastIndexOf(String)：返回这个最后的字符所在的位置；
split（String）：返回的是字符串；而且在split中的字符串会被去除；起到一个分割的作用；例如：Hello，split(e),得到的结果就是H，llo;
trim（）：去除字符串的首尾所有空格；
equalsIgnoreCase（String）：这是比较字符串忽略大小写；
substring(int)：这个方法用来从数字下标的字符开始选取一段字符串；
toLowercase() ：这个方法是把字符串全部变成小写；
toUppercase()：这个方法是将字符串全部变成大写；
replace（“老字符”，“新字符”）把老字符替换成新字符；
一个隶属于system的方法；直接这样使用：system.arraycopy(obj src,int1 ,obj2,int2,length):这里面src是一个数组对象，int1是第一个数组要从哪里开始复制的起始点，obj2那里是复制到的对象位置， int2的意思是第二个对象开始复制的起始点，至于最后的length是指第二个对象复制第一个的总长度；

3.StringBuilder和StringBuffer

StringBuilder线程不安全，但是效率高；StringBuffer线程安全，但是效率不高；
StringBuilder是可变序列，主要也是指建立一个新数组将老数组给替换掉；

public class TextStringBuilder {
	public static void main(String[] args) {
		StringBuilder str = new StringBuilder();//根据源码可以知道初始化的长度是16
		StringBuilder str1 = new StringBuilder("abcd");
		StringBuffer str3 = new StringBuffer();
		str.append("ssd");//在str字符后面添加ssd字符串；
		str.delete(0, 1);//删除0到1之间的字符；
		str.insert(0, "c");//在0的位置添加c字符
		str.reverse();//就是将字符串反向；
		for(int i=0;i<1000;i++) {
			str1.append(i);
		}
		System.out.println(str);
		System.out.println(str1);
	}
}

在源码中StringBuilder类和类StringBuilder继承抽象类AbstractStringBuilder。
StringBuilder类默认的初始长度是16；
toString()方法；（只是以字符串形式输出）；
tocharAt():显示出指定位置的字符；
一个构造器里可以直接调用另一个构造器，在一个类中；

4.多维数组

之前写过一维数组的创建和使用，对于多维数组好像没有记录，所以现在记一下；定义数组的时候要确定它的大小（也就是需要的内存空间）；

	public class Myarray {
	public static void main(String[] args) {
		int[][] a = {//在定义多维数组的同时，给其赋值；
				{1,2},
				{2,3}
		};
		
		int[][] b = new int[5][2]; //只是对其进行定义，之后赋值；
		System.out.println(a[1][1]);
	}
}

以下是我理解的多维数组的内存结构，当然，为了便于画图，我给数组的前后都定义了大小为2；

一维数组可以理解成一条x轴，而二维数组可以理解为x，y轴；
部分方法：

Arrays.toString(int a[]):打印出a数组的内容；
Arrays.binarySearch(int a[],int d):返回一个索引，就是d在数组a的下标位置；
当然可以通过foreach即for(类型：数组)来循环读取b数组的内容；

5.冒泡排序

比较相邻的元素，然后将第一个元素比第二个元素小的顺序排列；第一次排序后得到最大的那个数；

public class TextBubbleSort {
	public static void main(String[] args) {
		int[] values= {//定义一个数组；
			3,2,5,6,8,7,4,6,5,12,54,65,65,44,2,5,2,5,5,55,5,56,87,98	
		};
		for(int i=0;i<values.length;i++) {//让数组循环values.length次
		for(int j=0;j<values.length-1-i;j++) {//这里面的i可有可无，但是有的话可以使循环次数减少，因为每一次循环都可以得到一个最大值；
			if(values[j]>values[j+1]) {
				int t = values[j];
				values[j] = values[j+1];
				values[j+1] = t;
				System.out.println(Arrays.toString(values));
			}
			System.out.println("###########");
		}
		}
//		for(int p:values) {
//			System.out.println(p);
//		}
	}
}

6.二分法检索

二分法查找也成称为折半查找（数组必须是已经排好序的），每一次查找都减少一半；

public class TextbanirySearch {
	public static int MyBaniry(int[] arr, int value) {
		int low = 0;
		int high = arr.length - 1;
		while (low <= high) {
			int mid = (low + high) / 2;
			if (arr[mid] == value) {
				return mid;
			}
			if (arr[mid] > value) {
				high = mid - 1;
			}
			if (arr[mid] < value) {
				low = mid + 1;
			}
		}
		return -1;

	}

	public static void main(String[] args) {
		int[] values = { 3, 2, 5, 6, 8 };
		int value = 2;
		Arrays.sort(values);
		System.out.println(Arrays.toString(values));
		System.out.println(MyBaniry(values, value));
	}
}

以上是一个二分法的方法；

7.包装类

已知基本的数据类型有8种，因此包装类也有8中种，将其做成表格：

基本数据类型	包装类
int	Integer
byte	Byte
short	Short
char	Character
boolean	Boolean
long	Long
float	Float
double	Double

在Integer包装类中：

public class MyInteger {
	public static void main(String[] args) {
		Integer i = new Integer(100);
		System.out.println(Integer.toHexString(i));//答案是十六进制0X64
		Integer i2 = Integer.parseInt("123");
		System.out.println(i2);
		
		Integer i3 =1000;//相当于是Integer i3 = new Integer(1000);JDK1.5之后有的自动装箱；
		
		int i4 = new Integer(1000);//相当于是 new Integer(1000).intValue();
		
	}
}

toHexString(i)：将i的值转换为16进制；
Integer.parseInt(String)：将其中的字符串转化为数字，当然字符串是以数字的形式出现，比如“123”，“3”等；
还有intValue方法可以将其转化为数字；
在Integer中[-128,127]之间的数可以被直接当做基本类型数据来使用；
其他的数据类型都差不多；所以就不一一的给自己进行描写，我感觉应该还行；

8.时间类

（java.util.Date）

因为在Date类中大部分的方法都已经不建议使用了，所以看了一圈大概就这么多的方法。

public class TextMydata {
	public static void main(String[] args) {
		Date d1 = new Date(1);
		Date d2 = new Date(2);
		boolean b = d1.after(d2);//还有一个before
		System.out.println(b);
		System.out.println(d1.getTime());
	}
}

（DateFormat）

这个类看源码发现是一个抽象类，抽象类就是拥有抽象方法还无法继承的类；所以在创建对象的时候，只能借助他的子类，而无法直接用这个类创建，它的子类是SimpleDateFormat；（把时间转换为字符串或者把字符串转化为时间）

public class TextDateFormat {
	public static void main(String[] args) {
	//千万单词不要错，在API里面就是这么规定的，一旦单词错了，基本上日期显示就不对了；还有大写W，表示一月里面的周数，
		DateFormat df = new SimpleDateFormat("yyyy-MM-dd w hh:mm:ss");
		Date d = new Date(System.currentTimeMillis());
//		d.setTime(145456455456l);
		String str = df.format(d);
		System.out.println(str);
		String str1 = "1238,5,7";
		DateFormat df2 = new SimpleDateFormat("yyyy,dd,MM");
		try {
			Date d2 = df2.parse(str1); //把字符串转格式成日期；
			System.out.println(d2);
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

（Calendar）

这个类可以对时间进行计算，当然也可以进行定义，但是Calendar也是一个抽象类当要建立对象时还是要依靠他的子类。

public class TextCalendar {
	public static void main(String[] args) {
		Calendar cd = new GregorianCalendar();
		//如果不定义时间，那么他就会使用当前的时间；
		cd.set(1745, Calendar.JULY, 25, 12, 22, 55);
		cd.add(Calendar.DAY_OF_MONTH, 10);//可以进行时间的加减；
		Date d = cd.getTime();
		System.out.println(d);
	}

}

总结（通过输出得到所需要的简单日历）：

public class TextCanlandar {
	public static void main(String[] args) {
		while (true) {
			System.out.println("\n请按要求输入日期（2011-02-4）：\n");
			
			Scanner scanner = new Scanner(System.in);
			System.out.println("日\t一\t二\t三\t四\t五\t六\n");
			String input = scanner.next();
			DateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd");
			try {

				Date day = dateformat.parse(input);
				Calendar cd = new GregorianCalendar();
				cd.setTime(day);
				cd.set(Calendar.DATE, 1);
				int weekday = cd.get(Calendar.DAY_OF_WEEK);
				int Maxday=cd.getActualMaximum(Calendar.DAY_OF_MONTH);

				for (int i = 1; i < weekday; i++) {
					System.out.print("\t");
				}
				for (int i = 1; i < Maxday; i++) {
					System.out.print(i + "\t");
					if ((i + weekday - 1) % 7 == 0) {
						System.out.println("\n");
					}
				}
			} catch (ParseException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

		}
	}
}

以后学好了，还记得的情况下，我就把他做成程序；