从四种ADT操作角度书写对int string list下的几个类的理解

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

`在讲第六章ADT时，针对一些老师列举的类，我并不知道这些类的具体用法也很难据此反推四种ADT操作的区别。于是，我就自己挨个搜索各个类的用法和场景，在此进行一个归纳

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、四种ADT操作简述

Creators 构造器：
利用其他的数据类型对象产生一个新的对象

可能实现为构造函数或静态工厂方法

Producers 生产器：
用已有该类型对象产生新对象

Observers 观察器（不同于原类型）

Mutators 变值器（改变对象属性的方法）
通常范围void，如果返回void，则必然意味着它改变了某些对象的内部状态，也可能范围非空类型（如容器类的put、add方法）

二、int与string的类举例及讲解

1.int

Creators :定义一个数字

int i=1,j；

Producers :加入逻辑运算

j=1+1;

Observers :比较大小、是否相等的操作

if(i<j){
};

Mutators:int本身为不可变数据类型，故不存在变值器

2.string

Creators :定义一个字符串

int i="abc"；

Producers :加入逻辑运算也就是字符串的增加、减少、变为大写

public class HelloJava {
	private static String say1 = "我要";
	private static String say2 = "学会你";
	private static String say3 = "我要学会你";
	private static String say4 = "china";
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		System.out.println("Java"+say1.concat(say2));
		System.out.println(say3.substring(1,2));
		System.out.println(say4.toUpperCase());
	}

}

Observers :求长度、根据索引返回字符等操作

System.out.println(say3.length());
System.out.println(say3.charAt(1));	

Mutators:String本身为不可变数据类型，故不存在变值器

三、list的类举例及讲解

Creators :
ArrayList:基于动态数组的数据结构，允许任何元素的插入，甚至包括null。每一个ArrayList都有一个初始化的容量（10），该容量代表了数组的大小，随着容器中容量的不断增加，容器的大小也会随着增加。在每次向容器中增加元素时，会进行容量检查，当快溢出时，会进行扩容操作。

ArrayList list = new ArrayList();
        list.add(0);
        list.add(1);
        list.add(2);
        list.add(3); // 此时list : 0 1 2 3
        print("list", list);
        list.add(0, 4); //  在指定位置插入元素
        print("list", list); //  此时list ；4 0 1 2 3

LinkedList:基于链表的数据结构，双向列表可实现队列和栈

实现方法参考这篇博客
https://blog.csdn.net/i_lovefish/article/details/8042883?spm=1001.2101.3001.6650.1&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-1-8042883-blog-111604510.pc_relevant_default&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-1-8042883-blog-111604510.pc_relevant_default&utm_relevant_index=2

Collections.singletonList：Collections.singletonList()返回的是不可变的集合，但是这个长度的集合只有1，可以减少内存空间。但是返回的值依然是Collections的内部实现类，同样没有add的方法，调用add，set方法会报错

List<String> single = Collections.singletonList(say4);
System.out.println(single);	

Producers :
Collections.unmodifiableList:持有一个不可变的集合，不仅指向该集合的引用不可变，集合内的元素也不可变。下图代码在执行时会报错就是因为list1.add改变了tom的电话数

import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
public class Try
{
public static void main(String[] args){
    ArrayList<String> list = new ArrayList<String>();
    Customer s = new Customer("Tom", list);
    list.add("1234");
    list.add("3455");    
    List<String> list1 = s.getPhone();

        /**
         * throws java.lang.UnsupportedOperationException
         * should replace with s.addCourse(String course)
         */
        list1.add("999"); 

        //报错
        System.out.println("the amount of phone number = " + s.getPhone().size());        
    }

    public static class Customer
    {
        private String name;
        private ArrayList<String> phone;

        public Customer(String name, ArrayList<String> a)
        {
            this.name = name;
            this.phone = a;
        }

        public List<String> getPhone()
        {
            return Collections.unmodifiableList(phone);//返回的是不可以修改的phone 数组
        }

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

        public void addPhone(String phone1)
        {
            phone.add(phone1);
        }

        public String removePhone(String phone1)
        {
            boolean removed = phone.remove(phone1);

     if (removed)
     {
         return phone1;
     }
     else
     {
                return null;
     }
        }
    }
}

Observers :size,get

System.out.println(list.size());//自带的方法
public String getName()
        {
            return name;
        }

Mutators:
List本身为可变数据类型，存在变值器add,move,addAll,Collections.sort
addAll:add是将传入的参数作为当前List中的一个Item存储，即使你传入一个List也只会另当前的List增加1个元素。addAll是传入一个List，将此List中的所有元素加入到当前List中，也就是当前List会增加的元素个数为传入的List的大小。

Collection result = new ArrayList(); 
Collection list = new ArrayList();
result.addAll(list);

Collections.sort：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Test {

    private static final Logger LOGGER = LoggerFactory.getLogger(Test.class);

    public static void main(String[] args) {
        List<String> lists = new ArrayList<String>();
        lists.add("1");
        lists.add("5");
        lists.add("3");
       
        //排序，直接调用sort方法排序，排序方式是自燃排序，即升序排序
        Collections.sort(lists);
    }

}

总结

本文作为一个学习笔记起始帮助一起从0开始学软构对Java中类及对其具体实现不了解的伙伴提供一个个人的学习心得，了解类的应用场景是砖，好的类的定义是水泥。合适的代码需要二者的结合，以后的分享中或许还有如何书写更好的类的心得

https://blog.csdn.net/weixin_41973367/article/details/116672309
https://blog.csdn.net/hjl21/article/details/107839337
https://blog.csdn.net/weixin_39387961/article/details/111604510