Java基础[七]:数组、集合和字符串
7、数组、集合和字符串
7.1 数组
7.1.1 数组定义
7.1.2 一维数组
定义
- 一维数组（简称为数组）是由一组具有相同类型的变量组成的有序集合。
- 数组中的变量被称为数组元素。
- 每个元素在数组中的位置被称为元素的下标。
- 在JAVA中，数组是被当作对象来处理的。
一维数组的声明：
- 数组一般用来组合相同类型的对象。
- 数组允许通过公共的名称来引用该组对象。
- 数组声明创建一个引用，用它可以引用一个数组。
声明格式:
数组的类型：
创建数组:
例如，下面两种创建方式的意义相同。
int[ ] a=new int[10]；
int a[ ]=new int[10]；
创建基本类型数组：
例如，创建一个基本(char)类型数组：
public char[ ] createArray(){
char[ ] s;
s=new char[26];
for(int i=0;i<26;i++){
s[i]=(char)(‘A’+i);
}
return s;
}
另一示例，创建一个对象数组：
public Point[ ] createArray(){
Point[ ] p;
p=new Point[10];
for(int i=0;i<10;i++){
p[i]=new Point(i,i+1);
}
return p;
}
另一示例，创建一个对象数组：
public Point[ ] createArray(){
Point[ ] p=new Point[10];
for(int i=0;i<10;i++){
p[i]=new Point(i,i+1);
}
return p;
}
初始化数组-整型数组:
- 数组的初始化是指：在创建数组实例时进行元素的初始化。
例如，int[ ] group={0，1，2，3，4，5，6，7，8，9}； - 其意义是：首先创建一个长度为10的int型数组实例，并使它们的初值依次为给定的初值；
- 然后将该数组实例赋给引用名group。
写法一(动态初始化)：
int intArray[ ];
intArray=new int[5];
此时数组元素均为默认值0，可以逐个赋值：
intArray[0]=1;
intArray[1]=2;
intArray[2]=3;
写法二(静态初始化)：
int intArray[ ]=new int[]{1,2,3};
或
int intArray[ ]={1,2,3};
省略了指定数组大小，
此时数组的大小由大括号中值的个数决定，
这种方式需指定数组中各个元素的值。
初始化数组-对象数组：
写法一(动态初始化)：
Point PArray[ ];
PArray=new Point[3];
此时数组元素的值为默认值null，可逐个赋值：
PArray[0]=new Point(0,1);
PArray[1]=new Point(1,2);
PArray[2]=new Point(2,3);
写法二(静态初始化)：
Point PArray[ ]=new Point[]{
new Point(0,1),
new Point(1,2),
new Point(2,3)};
或
Point PArray[ ]={
new Point(0,1),
new Point(1,2),
new Point(2,3)};
初始化数组-字符串数组
写法一(动态初始化)：
String names[ ];
names=new String[3];
逐个赋值：
names[0]=“How”;
names[1]=“are”;
names[2]=“you”;
写法一(动态初始化)：
String names[ ];
names=new String[3];
names[0]=new String(“How”);
names[1]=new String(“are”);
names[2]=new String(“you”);
写法二(静态初始化)：
1.String names[ ]=new String[]{“How”,”are”,”you”};
2.String names[ ]={“How”,”are”,”you”};
3.String names[ ]={
new String(“How”),
new String(“are”),
new String(“you”)};
一维数组的重定义:
数组边界：
- 在Java编程语言中，所有数组的索引均从0开始。
- 数组的元素数作为数组对象的一部分存储在length属性中。
- 如果发生边界溢出访问，那么就将引发运行时异常。
使用length属性对数组作如下循环：
int list[ ]={1,2,3};
for(int i=0;i<list.length;i++){
System.out.println(list[i]);
}
数组的length 域:
对象数组复制：
数组的深度拷贝:
如果数组元素对象不支持深度拷贝，数组也无法支持深度拷贝
Point[] w = new Point[u.length];
for (int i = 0; i < u.length; ++i) {
w[i] = (Point) u[i].clone();
}
7.1.3 二维数组
二维数组的声明与定义：
二维数组的创建：
二维数组的初始化
初始化二维整型数组:
int [][]aVar=new int[][]{{1,2,3},{4,5,6}};
或
int [][]aVar={{1,2,3},{4,5,6}};
或
int a[][]=new int[2][];
a[0]=new int[]{1,2,3};
a[1]=new int[]{4,5,6};
错误的写法：
int a[][]=new int[2][];
a[0]={1,2,3};
a[1]={4,5,6};
初始化字符串数组:
String s[][]=new String[2][];
s[0]=new String[2];
s[1]=new String[2];
s[0][0]="good";
s[0][1]="luck";
s[1][0]="to";
s[1][1]="you";
错误的写法：
String s[][]=new String[2][];
s[0]={"good","luck"};
s[1]={"to","you"};
二维数组的访问:
int a[][]={{1,2,3},{3},{4,5,6}};
for(int i=0;i<a.length;i++)
for(int j=0;j<a[i].length;j++)
System.out.println(a[i][j]);
二维数组例子：
非矩阵二维数组示例（不推荐）
二维数组初始化:
二维数组例子：
二维数组遍历:
3列4行
for (int c = 0; c < m.length; ++c)
for (int r = 0; r < m[c].length; ++r) {
System.out.print("Enter a value: ");
m[c][r] = stdin.nextInt();
}
3行4列
for (int r = 0; r < m.length; ++r)
for (int c = 0; c < m[r].length; ++c) {
System.out.print("Enter a value: ");
m[r][c] = stdin.nextInt();
}
二维数组默认初始化：
多维数组需要注意的地方:
数组的限制:
7.2 集合
7.2.1 List
List接口： public interface List extends Collection
- 是Collection接口的子接口，列表，有顺序的集合
- 提供的方法：
- E get(int index)：返回列表中指定位置的元素
- E set(int index, E element)：用element替换列表中index处的元素
- void add(int index, E element)：在列表的指定位置插入指定元素
- E remove(int index)：移除列表中指定位置的元素
- int indexOf(Object o)：返回列表中首次出现指定元素的索引，如果列表不包含此元素，则返回 -1
List示例:
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class CC1 {
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
list.add(new Integer(6));
list.add(new Integer(9));
list.add(new Integer(3));
list.add(new Integer(5));
list.add(new Integer(6));
Iterator<Integer> it = list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
7.2.2 Set
Set接口：public interface Set extends Collection
- 是Collection接口的子接口
- 不包含重复元素的集合，模拟数学上的 “集合”
- 未引入新的方法
- 与List的区别是，List元素有位置概念，Set集合只有元素
import java.util.HashSet;
import java.util.Set;
public class Main {
public void hashSetExample() {
Set vehicles = new HashSet();
String item_1 = "Car";
String item_2 = "Bicycle";
String item_3 = "Tractor";
boolean result;
result = vehicles.add(item_1);
System.out.println(item_1 + ": " + result);
result = vehicles.add(item_2);
System.out.println(item_2 + ": " + result);
result = vehicles.add(item_3);
System.out.println(item_3 + ": " + result);
result = vehicles.add(item_1);
System.out.println(item_1 + ": " + result);
result = vehicles.add(null);
System.out.println("null: " + result);
result = vehicles.add(null);
System.out.println("null: " + result);
}
public static void main(String[] args) {
new Main().hashSetExample();
}
}
7.2.3 Vector
Vector：变长的对象数组
- public class Vectorextends AbstractListimplements List<E
- 可以根据下标来引用数组元素，可以追加对象元素数量，可以修改、删除其中的对象。
- Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。
Vector对象创建：
Vector类添加元素:
修改与删除元素Vector中的元素：
查找Vector中的元素：
public class Temp {
public static void main(String[] args) {
Vector strs = new Vector(10, 10);
strs.add("str1");
strs.add("str2");
strs.add("str3");
strs.add("str4");
strs.add("str5");
System.out.println(strs.toString());
String str = (String) strs.elementAt(0);
strs.set(2, "new str2");
strs.remove("str4");
Iterator<String> it = strs.iterator();
while (it.hasNext())
System.out.print(it.next() + " ");
}
}
7.3 Map
Map接口：
- 是一组成对的<键-值>对象，
- Map中不能有重复的键
- 包含HashMap、LinkedHashMap、TreeMap……
- 主要的方法有：
- V put(K key, V value);
- V get(Object key);
HashMap示例
public class T2 {
public static void main(String[] args) {
Map <String,String> map = new HashMap<String,String>();
map.put("1", "星期一");
map.put("2", "星期二");
map.put("3", "星期三");
map.put("4", "星期四");
map.put("5", "星期五");
map.put("6", "星期六");
map.put("7", "星期日");
Set<String> keys = map.keySet();
Iterator<String> it = keys.iterator();
while(it.hasNext()){
String key = it.next();
String value =map.get(key);
System.out.println(key+" "+value);
}
}
}
7.4 字符串
例子: 判断一个字符串中共出现几个en
class Test3
{ public static void main(String args[])
{ int number=0;
String s="student;entropy;engage,english,client";
for(int k=0;k<s.length();k++)
{ if(s.regionMatches(k,"en",0, 2))
{ System.out.printf("k=%d\n",k);
number++;
}
} //从k的位置开始取长度为2的字串，从“en”的0开始取长度为2的字串
System.out.println("number="+number);
}
}
//region 范围 区域 Match匹配
例子:
- String tom=“I am a good cat”;
- System.out.println(tom.indexOf(“I”));
- System.out.println(tom.indexOf(“a”));
- System.out.println(tom.indexOf(“a”,7));
- System.out.println(tom.indexOf(“good”));
- System.out.println(tom.indexOf(“w”,2));
- //index 标志 指示
例子:
- String tom=“I love them”;
- String s1=tom.substring(2);
- String s2=tom.substring(2,5);
- System.out.println(s1);
- System.out.println(s2);
7.5 泛型
BooleanFoo.java：
public class BooleanFoo {
private Boolean foo;
public void setFoo(Boolean foo) {
this.foo = foo;
}
public Boolean getFoo() {
return foo;
}
}
IntegerFoo.java：
public class IntegerFoo {
private Integer foo;
public void setFoo(Integer foo) {
this.foo = foo;
}
public Integer getFoo() {
return foo;
}
}
问题：
- 示例1与示例2中的两个类除了声明成员的类、参数行的类型和和方法返回值的类型不同之外，其余的代码完全相同
- 复制修改代码
- 返回值类型和参数行的类型使用Object类代替
ObjectFoo.java:
public class ObjectFoo {
private Object foo;
public void setFoo(Object foo) {
this.foo = foo;
}
public Object getFoo() {
return foo;
}
}
定义泛型类;
class Test<T> { private T a;… }
T：类型变量
GenericFoo.java：
public class GenericFoo<T> {
private T foo;
public void setFoo(T foo) {
this.foo = foo;
}
public T getFoo() {
return foo;
}
}
GenericFooDemo.java:
public class GenericFooDemo {
public static void main(String[] args) {
GenericFoo<Boolean> foo1 = new GenericFoo<Boolean>();
GenericFoo<Integer> foo2 = new GenericFoo<Integer>();
foo1.setFoo(new Boolean(true));
Boolean b = foo1.getFoo();
System.out.println(b);
foo2.setFoo(new Integer(10));
Integer i = foo2.getFoo();
System.out.println(i);
}
}
下一章节见https://blog.youkuaiyun.com/fageaaa/article/details/154516265
扫一扫
8150
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
