java第四章：数组与字符串

一、数组

数组：内存中连续存储的一组相同类型的数据（由此得出特征：连续存储、相同类型）

一维数组：

我们经常见到数组的声明有一下几种形式：int[] a=new int[10]; \n a[0]=1; \n a[1]=2;……

                                                                    int[] a={1,2,3……}；

那是因为数组的使用需经过：1、定义：定义形式有如下三种：int a[ ];

                                                                                                   int[ ] a;（推荐使用，与C语言区分开来）

                                                                                                   int [ ]a;

                                             2、创建：开创一个空间并将第一个元素的地址给数组，如：a=new int[10];

                                             3、初始化：静态初始化：a={1,2,3……}

                                                                 动态初始化：a[0]=1;

                                                                                      a[1]=2;

                                                                                      a[2]=3;……

一维数组的内存管理为（以int[] a=new int[3]为例）：a里边存储的是数组第一个元素的地址（因此数组是引用类型），[]内存                                                                                           数组开辟的空间大小           

                                                                                    

二维数组：

同样经过：1、定义：定义形式有：int a[][];

                                                        int[][] a;(推荐使用)

                                                        int[] a[];

                   2、创建：第二维度固定：a=new int[2][3];

                                   第二维度不固定：a=new int[2][];（这种情况下第一维度必须写上）

                  3、初始化：静态初始化：int[][] a={{1,2,3,},{4,5,6}};

                                      动态初始化：int[][] a=new int[2][];

                                                            a[0]=new int[3];

                                                            a[1]=new int[3];

                                                            a[0][0]=1;

                                                            a[0][1]=2;

                                                            a[0][2]=3;

                                                            a[1][0]=4;

                                                            a[1][1]=5;

                                                            a[1][2]=6;

二维数组内存管理：a里边存储a[0]的地址，a[0]里边存储a[0][0]的地址，a[0][0]里面存储元素。如下图：

                                                        

数组相关题型：1）斐波那契数列

                          2）排序（冒泡排序、选择排序、插入排序）

                          3）杨辉三角（不规则的）

public class MaoPao {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
//        冒泡排序（按小到大的顺序）
		int[] a= {45,7,23,90,6,12};
		for (int i = a.length-1; i > 0; i--) {
			//第一轮排下来得出最小数，第二轮排下来得到次小的数，有i个元素，就需要比较i-1轮
		for (int j = 0; j < a.length-1; j++) {
			//解决数组循环问题时注意循环次数与数组下标的关联，以免出现数组下标越界的异常
			int temp;//因为两数交换值时需要一个中间变量，所以定义一个临时变量
			if(a[j]>a[j+1])
			{
				temp=a[j];
				a[j]=a[j+1];
				a[j+1]=temp;//比较大小之后交换值
			}
		}
		}
		for (int i = 0; i < a.length; i++) {
			System.out.println(a[i]);
		}//因为是数组，所以最后打印结果要循环去遍历值
	}

}

public class SelectSort {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
//      选择排序：指定第一个数为最小数，然后拿后面的数与之比较，若小于它，则交换位置，依次比较。
     //每轮比较能得出一个最小数。
		int[] a={78,23,89,2,15};
		int k=0;//作为每轮比较的标志位
		for (int i = a.length-1; i > 0; i--) {
			//i个数需要比较i-1轮
		for (int j = 1; j < a.length; j++) {
			int temp;//作为两数交换的中间变量
			if(j>k) {
				//每轮只与a[k]后的数比较，不然前面已经是得出的较小数，交换位置之后就会打乱顺序
			if(a[j]<a[k])
			{
				temp=a[k];
				a[k]=a[j];
				a[j]=temp;
			}
			}
		}
		k++;//因为每轮之后会得出最小数，所以每轮之后应该更新标志位
		}
		for (int i = 0; i < a.length; i++) {
			System.out.println(a[i]);
		}
	}

}

public class InsertSort {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//插入排序
		int [] a = {3,65,9,100,2};
		int [] b = new int [a.length];
		b[0] = a[0];
		for (int i = 1; i < b.length; i++) {
			for (int j = 0; j <= i; j++) {
				if(j == i)//取出的数已经大于数组b中所有存在的数，将此数插到末尾
				{
					b[j] = a[i];
				}else if(a[i] < b[j]) {
				for (int k = i; k>=j; k--) {
					if(k == j) {
						b[k] = a[i];//插入
					}else
						b[k] = b[k - 1];//移位
				}
				break;
				}
				
			}
		}
		for (int i = 0; i < b.length; i++) {
			System.out.println(b[i]);
		}
	}

}

public class Fib {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
//      打印前十个斐波那契数
		int[] a=new int[10];
		a[0]=1;
		a[1]=1;
		a[2]=2;
		for (int i = 3; i < a.length; i++) {
			a[i]=a[i-1]+a[i-2];//第i个数等于第i-1与第i-2个数之和（斐波那契数列的特征）
		}
		for (int i = 0; i < a.length; i++) {
			System.out.println(a[i]);
		}
	}

}

public class test6 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//不规则的杨辉三角
        int[][] a=new int[10][10];
        for(int i=0;i<a.length;i++)
        {
        	for(int j=0;j<=i;j++)
        	{
        		if(i==j)
        		{
        			a[i][j]=1;
        		}else if(j==0)
        		{
        			a[i][j]=1;
        		}else {
        			a[i][j]=a[i-1][j-1]+a[i-1][j];
        		}
        		System.out.print(a[i][j]+"\t");
        	}
        	System.out.println();
        }
	}

}

二、字符串

  1、字符串的生成方式：1）String str=“hello”；  str里边存的是hello的地址（所以String也是引用类型），hello这个字符串存储在一个常量池里边，str本身存在栈里边

                                        2）String str1=new String（“hello”）；str1存储在栈里边，new String（“hello”）存在了堆里边

                                        3）char c={‘h‘，‘e‘，‘l‘，‘l‘，‘o’}； String str2=new String（c）；

                                        4）byte[] b={104,101,108,108,111}；String str3=new String（b）；

                                        5）通过截取字符串生成：char c={‘h‘，‘e‘，‘l‘，‘l‘，‘o’}；String str4=new String（c，1,1）；第一个为截取的初始位置，第二个为截取长度

2、常用方法（以String str=“hello”为例）：1）通过子串找下标：int index=str.indexOf("h")；index=0

                                                                                                       int index1=str.indexOf("h",fromIndex);fromIndex表示从某个位置开始查找

                                                                    2）给出下标，找对用的字符：char c=str.charAt(2); 结果为“l”

                                                                    3）判断前缀后缀：boolean bo1=startsWith（“e”）；结果为false

                                                                                                   boolean bo2=endsWith（“lo”）；结果为true

                                                                   4）截取字符串：String str=subString（int i）；从i位置开始截取至末尾

                                                                                              String str1=subString（int a，int b）；从a开始截取至b-1（算头不算尾），子串长度为b-a。如：String str1=subString（1,4）；结果为“ell”

                                                                  5）置换：String str2=str.replace(oldchar,newchar);用newchar替换oldchar，生成一个新的字符串，但原来那个不变，替换掉的是拷贝的那份字符串

                                                                  6）按照某种模式切割字符串：String str3=str.split(某种特征); 按照该字符串的某种特征切割字符串，结果返回字符串数组

                                                                  7）全部转换为大写：String str4=str.toUppercase();

                                                                  8）全部转换为小写：String str5=str.toLowercase();

                                                                  9）滤除字符串前面和末尾的空格：String str6=str.trim();

3、有关面试题：1）比较两个字符串是否一样：==         比较字符串对象是否一样

                                                                            equals   比较字符串内容是否一样

                          2）字符串长度与数组长度有什么区别：字符串的长度需调用length方法，数组的长度是属性

4、例题：键盘输入一个邮箱，判定邮箱地址是否合法。如果合法，输出用户名。解题点：合法的邮箱：1）一定有@   2）@一定在'.'的前面   3）@前面有用户名  4）@和‘.’之间不相邻

import java.util.Scanner;

public class Address {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		 //输入一个邮箱地址，判断是否是正确的地址
		Scanner sc = new Scanner(System.in);
		System.out.println("please input your address: ");
		String address = sc.next();
		if(address.contains("@") && address.contains("."))
		{
			if(address.indexOf("@") < address.indexOf(".")-1)//判断@与'.'是否相邻
			{
				String[] str = address.split("@");
				System.out.println(str[0]);
			}
			else
				System.out.println("your address is wrong");
		}
		else {
		System.out.println("your address is wrong");
		}
	}

}