java基础_String类，Date类、Arrays类、变量的分类、匿名对象、可变参数写法

java中的break,提供了标签名

标签名：
循环体{
	break 标签名;
}

标签名为任意的标识符

在for循环中遇到continue语句时，首先执行循环的增量部分，然后进行条件测试。while和do…while语句是跳过本次循环结束前的语句，
回到条件循环的测试部分

与break语句一样，continue语句也支持标签功能
标签名：循环体{
continue 标签名;
}

String类      String指定该变量为字符串类型
String(char a[])

String s=new string(a);等价于new String("good");	

String (char a[],offset,length)开始截取的位置和截取字符串的长度
**用+进行字符串之间的连接**
String str;int size=str.length();获取字符串的长度

获取字符串中字符的下标

String str="we are students";
int size=str.indexOf("a");检索位置为0-length-1

lastIndexOf(String str)获取字符串中字符串出现最后一次时的位置

获取指定索引位置的字符 str.charAt(int index)

字符串操作：：获取子字符串

1.str.substring(int beginIndex)
2.str.substring(int beginIndex,int endIndex)

3.trim()返回字符串的副本，忽略前导空格和尾部空格。语法格式：str.trim();
4.字符串替换，replace()的方法可以实现指定字符或者字符串的替换成为新的字符串
格式语法：str.replace(char oldchar,char newchar)
判断字符串的开始和结尾    str.startsWith(String prefix)  和   str.endsWith(String suffix)是否以指定的字符串开始
并且两函数的返回值都是boolean类型

判断字符串是否相等

1.str.equals(String otherstr)如果两个字符串具有相同的字符和长度，返回true
2.str.equalsIgnoreCase(String otherstr)该函数忽略了字符串的大小写

按字典顺序比较两个字符串

当String对象在参数字符串之前时比较结果为一个负整数，当位于参数字符串之后时结果为正整数，当与参数字符串相等时返回0
语法为：str.compareTo(String otherstr)

字母大小写转换

小写：str.toLowerCase()
大写：str.toUpperCase()

字符串分割

1.str.split(String sign)
2.str.split(String sign,int limit)

.split(",", -1);和.split(",")的区别在于：
String a=“a,b,c,“当使用a.split(”,”)时得到数组是：[a,b,c]，
而a.split(",",-1)得到的数组是：[a,b,c, ].
当使用.split(",", -1);会保存空值。

```java
import java.util.Date;
	public static void main(String[] args) {
		Date date=new Date();
		String year=String.format("%tY", date);
		String month=String.format("%tB", date);
		String day=String.format("%td", date);
		System.out.print("今年是"+year+"年"+month+day+"日");

		String hour=String.format("%tH", date);
		String min=String.format("%tM", date);
		String sec=String.format("%tS", date);
		System.out.print("现在是"+hour+"时"+min+"分"+sec+"秒");
	}

}

字符串生成器String-Builder

String str;
		StringBuilder builder=new StringBuilder("");
		long starTime = System.currentTimeMillis();
		for(int j=0;j<100000;j++)
		{
			builder.append(j);
		}
		long endTime = System.currentTimeMillis();
		long time;
		time=endTime-starTime;
		System.out.print(time);

1.append()函数用于向字符串生成器中追加内容；append(content);
append函数是向string 的后面追加字符或字符串。
2.insert(int offset arg)

StringBuilder bf=new StringBuilder("hello");
bf.insert(5,"world");
System.out.println(bf.toString());

3.delete(int start,int end)start和end为将要删除的位置

StringBuilder bf=new StringBuilder("hello world");
bf.delete(5,10);
System.out.println(bf.toString());

二维数组初始化 type arrayname[][]={value1,value2…}

public static void main(String[] args) {
		int a[][]=new int[3][4];
		for(int i=0;i<a.length;i++)
		{
			for(int j=0;j<a[i].length;j++)
			{
				System.out.print(a[i][j]);
			}
			System.out.println();
		}
	}
}

循环遍历的foreach语句：

int a[][]= {{1,2},{3,4}};
for(int x[]:a)//访问数组的第一维   借助中间数组x[]访问
		{
			for(int j:x)//借助中间变量j访问x[]第二维每个元素
			{
				System.out.print(j+"  ");
			}
		}

foreach语句，借助中间变量的接力赛

填充替换数组元素：通过Arrays类的静态方法fill()可以完成数组元素的替换

1.使用格式：Arrays.fill(int[] a,int value)使用同一个值对数组进行填充    需要导入import java.util.Arrays;
2.使用格式：Arrays.fill(int[] a,int fromIndex,int toIndex,int value)其中toIndex不被包括在改变数值的范围之中。

对数组进行排序依然用到Arrays类

Arrays.sort(数组名);按照字母表字典的顺序进行排序，数字为从小到大的顺序排列，可以引入中间变量进行倒序

复制数组：1.Arrays.copyOf(arr,int newlength);newlength代表只copy数组的前五个元素
2.格式：Arrays.copyOfRange(arr,int fromIndex,int toIndex)

其中不包括toIndex;

1.查询数组：Array.binarysearch(Object[] a,object key)
a为要搜索的数组    key为要搜索的值
2.Arrays.binarysearch(object[],int fromIndex,int toIndex,Object key)

对象是实体需要被创建
类是规范，根据类的定义创建对象 类定义了对象，对象是类的实体
对象=属性+服务 数据：属性或状态 操作：函数把数据和对数据的操作放在一起==封装
创建对象new VendingMachine();
VendingMachine V=new VendingMachine();
对象变量是对象的管理者

.运算符
v.insertMoney();
v.getFood();

类定义了对象中所具有的变量，这些变量称为成员变量
每个对象都有自己的变量，和同一个类的其他对象是分开的

函数和成员变量

在函数中可以直接写成员变量的名字来访问成员变量

函数是通过对象来调用的     v.insertMoney()
这次调用建立了临时的insertMoney()和V之间的关系
让insertMoney()内部的成员变量指的是v的成员变量

this是成员函数的一个特殊的固有的本地变量，他表达了调用这个函数的那个对象   this.变量

调用函数：通过.这个运算符调用某个对象的函数，在成员函数内部直接调用函数就行，在成员函数外部需要指明对象再调用

本地变量：定义在函数内部的变量   本地变量的作用域和生存期都在函数内部
成员变量：生存期是对象的生存期，作用域是类内部的成员函数

构造函数：如果有一个成员函数的名字和类的名字相同，则在创建这个类的每一个对象的时候会自动调用这个函数--->构造函数
这个函数不能有返回类型，但是可有参数

函数重载：一个类可以有多个构造函数，只要他们的参数表不同
创建对象时给出不同的参数，就会调用不同的构造函数，通过this()还可以调用其他构造函数
一个类的同名但是参数表不同的函数构成重载关系

类的成员--属性    语法格式：修饰符  类型  属性名=初值；
修饰符：private：该属性只能由该类的方法访问
修饰符public：该修饰符可以被该类以外的方法访问    类型：任何基本类型，如int，boolean等
所有变量：局部变量(方法内的需要初始化)和成员变量
成员变量：实例变量(不以static修饰)  类变量(以static修饰)
局部变量：形参(方法签名中定义的变量)、方法局部变量(在方法内定义)；代码块局部变量(在代码块定义)

public static String sex=“man”;//这样的变量不需要实例化成对象就可以使用，直接可以通过类名.属性直接调用，此变量称为类变量
person p1=new person();
person.sex;
方法内可以调用方法，不能定义方法

匿名对象：直接调用对象的方法，new person().name;
使用情况：如果对一个对象进行一次方法调用，那么就可以使用匿名对象
经常将匿名对象作为实参传递的一个方法调用

类的访问机制：类中的方法可以访问类中的成员变量（例外：static的方法不能访问非static的成员变量，编译不通过）
在不同类中的访问机制：先创建要访问类的对象，再用对象访问类中定义的成员
对象.属性 对象.方法

方法的重载：重载的概念：在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数或参数类型不同即可。
重载的特点：与返回值类型无关，只看参数列表，且参数列表必须不同。调用时，根据方法参数列表的不同来区别。
参数顺序不同也构成重载。

Integer类，Long类，Short类定义基本数据类型int，long，short封装成一个类
构造方法：Integer number=new Interger(7)   Integer (int number)
Integer number=new Integer("45")                 Integer(Stringm str)

变长参数的写法
1

.public void showInfo(String[] args)//用数组的方式传递可变个数的参数
	{
		for(int i=0;i<args.length;i++)
		{
			System.out.println(args[i]);
		}
	}
public static void main(String[] args) {
		test5 xia=new test5();
		String[] ss=new String[] {"xiaxiaop","24","17806287063"};//没有参数时需要填写NULL
		xia.showInfo(ss);
	}

public void showInfo(String... args)//用数组的方式传递可变个数的参数
	{
		for(int i=0;i<args.length;i++)
		{
			System.out.println(args[i]);
		}
	}

public static void main(String[] args) {
		test5 xia=new test5();
		//String[] ss=new String[] {"xxx","24","xxx"};
		xia.showInfo("xxx","24","xxx");//没有参数时可以不填
	}

这两种方式效果一致。但是第二种方式更加方便

可变参数的类型为：public static void test(int a,String[] books);
public static void test(int a,String...books)
说明：1.可变参数：方法参数部分指定类型的参数个数是可变多个的
2.声明方式：方法名(参数的类型名)
3.可变参数方法的使用与方法参数部分使用是一致的
4.方法的参数部分有可变形参，需要放在形参声明的最后