Java基础知识之集合框架(一)

最新推荐文章于 2023-02-14 20:47:21 发布

总会有这一天的到来

最新推荐文章于 2023-02-14 20:47:21 发布

阅读量305

点赞数

分类专栏： Java基础学习

本文链接：https://blog.csdn.net/qq_33816875/article/details/50846069

版权

Java基础学习专栏收录该内容

11 篇文章 0 订阅

订阅专栏

一、集合类概述
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，Java就提供了集合类。

数组和集合类同是容器，有何不同？
数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。
对象数组
数组既可以存储基本数据类型，也可以存储引用类型。它存储引用类型的时候的数组就叫对象数组。
集合类的特点
集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

多个集合类的数据结构不同,结构不同不重要的，重要的是你要能够存储东西，并且还要能够使用这些东西，比如说判断，获取等。
既然这样，那么，这多个集合类是有共性的内容的，我们把这些集合类的共性内容不断的向上提取，最终就能形成集合的继承体系结构。

数据结构：数据的存储方式。

Collection:是集合的顶层接口，它的子体系有重复的，有唯一的，有有序的，有无序的。

二、 Collection

Collection 层次结构中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。
一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。
Collection
|--List 元素是有序的，元素可以重复。因为该集合体系有索引。
|--Set 元素是无序的，元素不可以重复。

Collection中的方法
1：添加功能
boolean add(Object obj):添加一个元素
boolean addAll(Collection c):添加一个集合的元素
2:删除功能
void clear():移除所有元素
boolean remove(Object o):移除一个元素
boolean removeAll(Collection c):移除一个集合的元素，只要有一个元素被移除了，就返回true。
3:判断功能
boolean contains(Object o)：判断集合中是否包含指定的元素
boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素，只有包含所有的元素，才叫包含
boolean isEmpty()：判断集合是否为空
4:获取功能
Iterator<E> iterator()：获取集合中的所有元素。迭代器，集合的专用遍历方式
5:长度功能
int size():元素的个数

6:交集功能
boolean retainAll(Collection c):两个集合都有的元素?思考元素去哪了，返回的boolean又是什么意思呢?
7：把集合转换为数组
Object[] toArray()

面试题：数组有没有length()方法呢?字符串有没有length()方法呢?集合有没有length()方法呢?
数组没有length()方法，但是有length这个属性
字符串有length()这个方法
集合有size()方法
三、 Iterator

1、概述
迭代是取出集合中元素的一种方式。
对于集合的元素取出这个动作,当不足以用一个函数来描述，需要用多个功能来体现，所以就将取出这个动作封装成一个对象来描述。
就把取出方式定义在集合的内部，这样取出方式就可以直接访问集合内部的元素。那么取出方式就被定义成了内部类。
而每一个容器的数据结构不同，所以取出的动作细节也不一样。但是都具有共性内容：判断和取出。那么就可以将这些共性抽取。

那么这些内部类都符合一个规则（或者说都抽取出来一个规则）。该规则就是Iterator。
通过一个对外提供的方法：iterator();，来获取集合的取出对象。
因为Collection中有iterator方法，所以每一个子类集合对象都具备迭代器。

Iterator iterator():迭代器，集合的专用遍历方式
Object next():获取元素,并移动到下一个位置。
NoSuchElementException：没有这样的元素，因为你已经找到最后了。
boolean hasNext():如果仍有元素可以迭代，则返回 true。

//储存学生对象，并用迭代器遍历
public class IteratorTest {
	public static void main(String[] args) {
		// 创建集合对象
		Collection c = new ArrayList();

		// 创建学生对象
		Student s1 = new Student("张三", 20);
		Student s2 = new Student("李四", 30);
		Student s3 = new Student("王五", 40);

		// 把学生添加到集合中
		c.add(s1);
		c.add(s2);
		c.add(s3);

		// 遍历
		Iterator it = c.iterator();
		while (it.hasNext()) {
			// System.out.println(it.next());
			Student s = (Student) it.next();
			System.out.println(s.getName() + "---" + s.getAge());
		}

		 System.out.println("----------------------------------");

		 //for循环改写,
		 for(Iterator it = c.iterator();it.hasNext();){
			 Student s = (Student) it.next();
			 System.out.println(s.getName() + "---" + s.getAge());
		 }
	}
}

四、 List
1.List:(面试题List的子类特点)
ArrayList:
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
Vector:
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
LinkedList:
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。

List有三个子类，到底使用谁?
看需求(情况)。

要安全吗?
要：Vector(即使要安全，也不用这个了，后面有替代的)
不要：ArrayList或者LinkedList
查询多：ArrayList
增删多：LinkedList

如果你什么都不懂，就用ArrayList。

2.List 集合的特点：
有序(存储和取出的元素一致)，可重复的。
3.List特有的方法

添加功能
void add(int index,Object element):在指定位置添加元素
获取功能
Object get(int index):获取指定位置的元素
列表迭代器
ListIterator listIterator()：List集合特有的迭代器
删除功能
Object remove(int index)：根据索引删除元素,返回被删除的元素
修改功能
Object set(int index,Object element):根据索引修改元素，返回被修饰的元素

4.List集合的特有遍历功能：
size()和get()方法结合使用

public class ListDemo2 {
	public static void main(String[] args) {
		// 创建集合对象
		List list = new ArrayList();

		// 添加元素
		list.add("hello");
		list.add("world");
		list.add("java");

		
		for (int x = 0; x < list.size(); x++) {
			String s = (String) list.get(x);
			System.out.println(s);
		}
	}
}

五、 ListIterator

在迭代的时候，不可以通过集合对象的方法操作元素，因为会发生（并发执行）异常
所以，在迭代的时候，只能用迭代器的方法操作元素，可是Iterator方法是有限的，只能对元素今夕判断，取出，删除的操作。
如果想要使用其他的操作比如，添加，修改等，就需要使用其子接口ListIterator，该接口只能通过List集合的ListIterator方式获取。
List集合特有的迭代器，该迭代器继承了Iterator迭代器，所以，就可以直接使用hasNext()和next()方法。
ListIterator可以实现逆向遍历，但是必须先正向遍历，才能逆向遍历，所以一般无意义，不使用。
并发执行异常解决方案
a:迭代器遍历，迭代器修改(ListIterator)
元素添加在刚才迭代的位置
b:集合遍历，集合修改(size()和get())
元素添加在集合的末尾
特有功能：
Object previous():获取上一个元素
boolean hasPrevious():逆向遍历列表，判断是否有元素。

		//判断里面有没有"world"这个元素，如果有，就添加一个"javaee"元素
public class ListIteratorDemo2 {
	public static void main(String[] args) {
		// 创建List集合对象
		List list = new ArrayList();
		// 添加元素
		list.add("hello");
		list.add("world");
		list.add("java");

		// 方式1：迭代器迭代元素，迭代器修改元素
		// 而Iterator迭代器却没有添加功能，所以我们使用其子接口ListIterator
		 ListIterator lit = list.listIterator();
		 while (lit.hasNext()) {
		 String s = (String) lit.next();
		 if ("world".equals(s)) {
		 lit.add("javaee");
		 }
	 }

		// 方式2：集合遍历元素，集合修改元素(普通for)
		for (int x = 0; x < list.size(); x++) {
			String s = (String) list.get(x);
			if ("world".equals(s)) {
				list.add("javaee");
			}
		}

		System.out.println("list:" + list);
	}
}

六、常见的数据结构
数据结构：就是数据的储存方式
栈：先进后出举例：子弹夹
队列：先进先出举例：排队买票
数组：储存同一种类型的多个元素的容器，有索引，方便获取。查询快，增删慢
链表：由一个链子把多个结点连接起来的数据,结点：由数据和地址组成(数据域和指针域)。查询慢，增删快。
树：二叉树，把第一个存入的元素作为根节点，
从第二个元素开始，每个元素都跟根节点比较，大的就放在右边，小的在左边。相等不存入。
哈希表：是一个元素为链表的数组，综合了数组合链表的好处。

七、 ArrayList
底层数据结构是数组，查询快，增删慢
线程不安全，效率高
ArrayList没有特有功能，功能都跟List一样

八、 Vector
底层数据结构是数组，查询快，增删慢
线程安全，效率低
Vector类特有功能
public void addElement(E obj)：添加元素
public E elementAt(int index)：根据索引获取值
public Enumeration elements()：获取所有元素，遍历
boolean hasMoreElements()：判断是否有元素
Object nextElement()：获取元素
Enumeration就是Vector特有的取出方式，其实枚举和迭代是一样的，因为枚举的名称和方法的名称都过长，所以被迭代器所取代了。

九、 LinkedList

底层数据结构是链表，查询慢，增删快
线程不安全，效率高
LinkedList类特有功能

添加功能
public void addFirst(Object e)
public void addLast(Object e)
获取功能
public Object getFirst()
public Obejct getLast()
删除功能
public Object removeFirst()
public Object removeLast()

	练习：ArrayList去除集合中字符串的重复值(字符串的内容相同)
 /*
	分析：
  		A:创建集合对象
  		B:添加多个字符串元素(包含内容相同的)
  		C:创建新集合
  		D:遍历旧集合,获取得到每一个元素
  		E:拿这个元素到新集合去找，看有没有
  			有：不添加
  			没有：就添加到新集合
  		F:遍历新集合
 */
public class ArrayListDemo {
	public static void main(String[] args) {
		// 创建集合对象
		ArrayList array = new ArrayList();

		// 添加多个字符串元素(包含内容相同的)
		array.add("hello");
		array.add("world");
		array.add("java");
		array.add("world");
		array.add("java");
		array.add("world");
		array.add("world");
		array.add("world");
		array.add("world");
		array.add("java");
		array.add("world");

		// 创建新集合
		ArrayList newArray = new ArrayList();

		// 遍历旧集合,获取得到每一个元素
		Iterator it = array.iterator();
		while (it.hasNext()) {
			String s = (String) it.next();

			// 拿这个元素到新集合去找，看有没有
			if (!newArray.contains(s)) {
				newArray.add(s);
			}
		}

		// 遍历新集合
		for (int x = 0; x < newArray.size(); x++) {
			String s = (String) newArray.get(x);
			System.out.println(s);
		}
	}
}

	练习：需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
/*
  要求：不能创建新的集合，就在以前的集合上做。
 */
public class ArrayListDemo2 {
	public static void main(String[] args) {
		// 创建集合对象
		ArrayList array = new ArrayList();

		// 添加多个字符串元素(包含内容相同的)
		array.add("hello");
		array.add("world");
		array.add("java");
		array.add("world");
		array.add("java");
		array.add("world");
		array.add("world");
		array.add("world");
		array.add("world");
		array.add("java");
		array.add("world");

		// 由选择排序思想引入，我们就可以通过这种思想做这个题目
		// 拿0索引的依次和后面的比较，有就把后的干掉
		// 同理，拿1索引...
		for (int x = 0; x < array.size() - 1; x++) {
			for (int y = x + 1; y < array.size(); y++) {
				if (array.get(x).equals(array.get(y))) {
					array.remove(y);
					y--;
				}
			}
		}

		// 遍历集合
		Iterator it = array.iterator();
		while (it.hasNext()) {
			String s = (String) it.next();
			System.out.println(s);
		}
	}
}

	练习：需求：去除集合中自定义对象的重复值(对象的成员变量值都相同)
/* 
  contains()方法的底层依赖的是equals()方法。
  而我们的学生类中没有equals()方法，默认使用的是它父亲Object的equals()方法
  Object()的equals()默认比较的是地址值，所以，它们进去了。因为new的东西，地址值都不同。
  按照我们自己的需求，比较成员变量的值，重写equals()即可。
  自动生成就可以
 */

public class Student {
	private String name;
	private int age;

	public Student() {
		super();
	}

	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

}

public class ArrayListDemo3 {
	public static void main(String[] args) {
		// 创建集合对象
		ArrayList array = new ArrayList();

		// 创建学生对象
		Student s1 = new Student("张三", 30);
		Student s2 = new Student("李四", 40);
		Student s3 = new Student("王五", 35);
		Student s4 = new Student("赵六", 38);
		Student s5 = new Student("王五", 61);
		Student s6 = new Student("张三", 30);
		Student s7 = new Student("张三", 18);

		// 添加元素
		array.add(s1);
		array.add(s2);
		array.add(s3);
		array.add(s4);
		array.add(s5);
		array.add(s6);
		array.add(s7);

		// 创建新集合
		ArrayList newArray = new ArrayList();

		// 遍历旧集合,获取得到每一个元素
		Iterator it = array.iterator();
		while (it.hasNext()) {
			Student s = (Student) it.next();

			// 拿这个元素到新集合去找，看有没有
			if (!newArray.contains(s)) {
				newArray.add(s);
			}
		}

		// 遍历新集合
		for (int x = 0; x < newArray.size(); x++) {
			Student s = (Student) newArray.get(x);
			System.out.println(s.getName() + "---" + s.getAge());
		}
	}
}

	练习：请用LinkedList模拟栈数据结构的集合，并测试

public class MyStack {
	private LinkedList link;

	public MyStack() {
		link = new LinkedList();
	}

	public void add(Object obj) {
		link.addFirst(obj);
	}

	public Object get() {
		// return link.getFirst();
		return link.removeFirst();
	}

	public boolean isEmpty() {
		return link.isEmpty();
	}
}
public class MyStackDemo {
	public static void main(String[] args) {
		// 创建集合对象
		MyStack ms = new MyStack();

		// 添加元素
		ms.add("hello");
		ms.add("world");
		ms.add("java");
		
		while(!ms.isEmpty()){
			System.out.println(ms.get());
		}
	}
}

十、泛型(Generic)
1.概述
泛型：JDK1.5版本以后出现的新特性，用于解决安全问题，是一个类型安全机制
是一种把类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。
参数化类型，把类型当作参数一样的传递。
好处：将运行时期出现的问题，(ClassCastException)转移到了编译时期，方便程序员解决问题，让运行时问题减少、安全。
避免了强制类型转换。
优化了程序设计，解决了黄色警告线
格式：
通过<>来定义要操作的引用数据类型
在使用Java提供的对象时，什么时候写泛型？
只要见到<>就要定义泛型。其实<>就是用来接收类型的。
ArrayList<String> al = new ArrayList<String>();
JDK1.7以后的新特性，泛型推断
ArrayList<String> al = new ArrayList<>();
当使用集合时，将集合中要储存的数据类型作为参数传递到<>中即可

为什么会有泛型呢?
早期的Object类型可以接收任意的对象类型，
但是在实际的使用中，会有类型转换的问题。
也就存在这隐患，所以Java提供了泛型来解决这个安全问题。
2.泛型应用
什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候。早期定义Object来完成扩展，现在定义泛型类来完成扩展。
泛型类定义的泛型，在整个类中有效，如果被方法的使用，
那么泛型的对象明确要操作的具体类型后，所有要操作的类型就已经固定了
泛型类
把泛型定义在类上
格式:public class 类名<泛型类型1,…>
注意:泛型类型必须是引用类型

泛型方法
把泛型定义在方法上
格式:public <泛型类型> 返回类型方法名(泛型类型 .)
特殊之处:
静态方法不可以访问类上定义的泛型
如果静态方法操作的应用数据类型不确定，可以将反省定义在方法上。
泛型接口
把泛型定义在接口上
格式:public interface 接口名<泛型类型1…>
泛型高级通配符
?：
通配符也可以理解为占位符，当数据类型不明确的时候可以使用，
使用通配符的好处是可以不用明确传入的类型，这样在使用泛型类或者泛型方法时，提高了扩张性。
? extends E：
可以接收E及E的子类。限定上限
? super E
可以接收E及E的父类。限定下限
十一、JDK1.5的新特性
1.泛型
2.增强for
3.静态导入
4.自动装箱拆箱
5.可变参数
6.枚举

增强for:是for循环的一种。
格式：
for(元素数据类型变量 : 数组或者Collection集合) {
使用变量即可，该变量就是元素
}

好处：简化了数组和集合的遍历。

弊端：增强for的目标不能为null。
如何解决呢? 对增强for的目标先进行不为null的判断，然后在使用。

//ArrayList存储字符串并遍历。要求加入泛型，并用增强for遍历。
public class ArrayListDemo {
	public static void main(String[] args) {
		// 创建集合对象
		ArrayList<String> array = new ArrayList<String>();

		// 创建并添加元素
		array.add("hello");
		array.add("world");
		array.add("java");

		// 遍历集合
		// 迭代器
		Iterator<String> it = array.iterator();
		while (it.hasNext()) {
			String s = it.next();
			System.out.println(s);
		}
		System.out.println("------------------");

		// 普通for
		for (int x = 0; x < array.size(); x++) {
			String s = array.get(x);
			System.out.println(s);
		}
		System.out.println("------------------");

		// 增强for
		for (String s : array) {
			System.out.println(s);
		}
	}
}


 // 需求：ArrayList存储自定义对象并遍历。要求加入泛型，并用增强for遍历。
 
public class ArrayListDemo2 {
	public static void main(String[] args) {
		// 创建集合对象
		ArrayList<Student> array = new ArrayList<Student>();

		// 创建学生对象
		Student s1 = new Student("张三", 30);
		Student s2 = new Student("李四", 20);
		Student s3 = new Student("王五", 40);
		

		// 把学生对象添加到集合中
		array.add(s1);
		array.add(s2);
		array.add(s3);
	
		// 迭代器
		Iterator<Student> it = array.iterator();
		while (it.hasNext()) {
			Student s = it.next();
			System.out.println(s.getName() + "---" + s.getAge());
		}
		System.out.println("---------------");

		// 普通for
		for (int x = 0; x < array.size(); x++) {
			Student s = array.get(x);
			System.out.println(s.getName() + "---" + s.getAge());
		}
		System.out.println("---------------");

		// 增强for
		for (Student s : array) {
			System.out.println(s.getName() + "---" + s.getAge());
		}
	}
}

静态导入：
格式：import static 包名….类名.方法名;
可以直接导入到方法的级别

静态导入的注意事项：
A:方法必须是静态的
B:如果有多个同名的静态方法，容易不知道使用谁?这个时候要使用，必须加前缀。

可变参数：定义方法的时候不知道该定义多少个参数
格式：
修饰符返回值类型方法名(数据类型… 变量名){

}

注意：
这里的变量其实是一个数组
如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

<strong>十二、练习</strong>
	1.集合的嵌套遍历
  
	  需求：
			每一个学生都是一个对象。可以使用一个集合表示一个班级的学生。ArrayList<Student>
			但是还有班级，每个班级也是一个ArrayList<Student>。
			现在有多个ArrayList<Student>。也要用集合存储，
			即：ArrayList<ArrayList<Student>>
 
public class ArrayListDemo {
	public static void main(String[] args) {
		// 创建大集合
		ArrayList<ArrayList<Student>> bigArrayList = new ArrayList<ArrayList<Student>>();

		// 创建第一个班级的学生集合
		ArrayList<Student> firstArrayList = new ArrayList<Student>();
		// 创建学生
		Student s1 = new Student("唐僧", 30);
		Student s2 = new Student("孙悟空", 29);
		Student s3 = new Student("猪八戒", 28);
		Student s4 = new Student("沙僧", 27);
		Student s5 = new Student("白龙马", 26);
		// 学生进班
		firstArrayList.add(s1);
		firstArrayList.add(s2);
		firstArrayList.add(s3);
		firstArrayList.add(s4);
		firstArrayList.add(s5);
		// 把第一个班级存储到学生系统中
		bigArrayList.add(firstArrayList);

		// 创建第二个班级的学生集合
		ArrayList<Student> secondArrayList = new ArrayList<Student>();
		// 创建学生
		Student s11 = new Student("诸葛亮", 30);
		Student s22 = new Student("司马懿", 28);
		Student s33 = new Student("周瑜", 26);
		// 学生进班
		secondArrayList.add(s11);
		secondArrayList.add(s22);
		secondArrayList.add(s33);
		// 把第二个班级存储到学生系统中
		bigArrayList.add(secondArrayList);

		// 创建第三个班级的学生集合
		ArrayList<Student> thirdArrayList = new ArrayList<Student>();
		// 创建学生
		Student s111 = new Student("宋江", 40);
		Student s222 = new Student("吴用", 35);
		Student s333 = new Student("高俅", 30);
		Student s444 = new Student("李师师", 22);
		// 学生进班
		thirdArrayList.add(s111);
		thirdArrayList.add(s222);
		thirdArrayList.add(s333);
		thirdArrayList.add(s444);
		// 把第三个班级存储到学生系统中
		bigArrayList.add(thirdArrayList);

		// 遍历集合
		for (ArrayList<Student> array : bigArrayList) {
			for (Student s : array) {
				System.out.println(s.getName() + "---" + s.getAge());
			}
		}
	}
}



	2.获取10个1-20之间的随机数，要求不能重复
/* 
	分析：
  		A:创建产生随机数的对象
  		B:创建一个存储随机数的集合。
  		C:定义一个统计变量。从0开始。
  		D:判断统计遍历是否小于10
  			是:先产生一个随机数，判断该随机数在集合中是否存在。
  					如果不存在:就添加，统计变量++。
  					如果存在:不管。
  			否：不管
  		E:遍历集合
 */
public class RandomDemo {
	public static void main(String[] args) {
		// 创建产生随机数的对象
		Random r = new Random();

		// 创建一个存储随机数的集合。
		ArrayList<Integer> array = new ArrayList<Integer>();

		// 定义一个统计变量。从0开始。
		int count = 0;

		// 判断统计遍历是否小于10
		while (count < 10) {
			//先产生一个随机数
			int number = r.nextInt(20) + 1;
			
			//判断该随机数在集合中是否存在。
			if(!array.contains(number)){
				//如果不存在:就添加，统计变量++。
				array.add(number);
				count++;
			}
		}
		
		//遍历集合
		for(Integer i : array){
			System.out.println(i);
		}
	}
}
 3.键盘录入多个数据，以0结束，要求在控制台输出这多个数据中的最大值
/*
  分析：
  		A:创建键盘录入数据对象
  		B:键盘录入多个数据,我们不知道多少个，所以用集合存储
  		C:以0结束,这个简单，只要键盘录入的数据是0，我就不继续录入数据了
  		D:把集合转成数组
  		E:对数组排序
  		F:获取该数组中的最大索引的值
 */
public class ArrayListDemo {
	public static void main(String[] args) {
		// 创建键盘录入数据对象
		Scanner sc = new Scanner(System.in);

		// 键盘录入多个数据,我们不知道多少个，所以用集合存储
		ArrayList<Integer> array = new ArrayList<Integer>();

		// 以0结束,这个简单，只要键盘录入的数据是0，我就不继续录入数据了
		while (true) {
			System.out.println("请输入数据：");
			int number = sc.nextInt();
			if (number != 0) {
				array.add(number);
			} else {
				break;
			}
		}

		// 把集合转成数组
		Integer[] i = new Integer[array.size()];
		array.toArray(i);
		
		// 对数组排序
		//可以使用Arrays工具类的排序方法
		Arrays.sort(i);

		// 获取该数组中的最大索引的值
		System.out.println("数组是：" + arrayToString(i) + "最大值是:"
				+ i[i.length - 1]);
	}

	public static String arrayToString(Integer[] i) {
		StringBuilder sb = new StringBuilder();

		sb.append("[");
		for (int x = 0; x < i.length; x++) {
			if (x == i.length - 1) {
				sb.append(i[x]);
			} else {
				sb.append(i[x]).append(", ");
			}
		}
		sb.append("]");

		return sb.toString();
	}
}