JAVA基础　－集合

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

/**
 * 列表 ArrayList,LinkedList
 * 1、值列表和对象列表 contains与indexOf测试
 * 2、基于LinkedList构建堆栈 push pop和队列 offer poll
 * <p>
 * Set HashSet,TreeSet   无序，不可重复
 * 1、HashSet比较hashcode()，再比较equals()
 * 2、TreeSet比较comparable和comparator
 * <p>
 * Map
 * 1、HashMap，2次添加相同key,之前value被覆盖； key为引用类型，则Hash也需实现hashCode和equals方法
 * 2、TreeMap  key为引用类型，同样是实现  comparable和comparator
 */
@Data
public class CollectionTest {
 
    @Test
    public void testList() {
        ArrayList<Integer> integers = new ArrayList<Integer>();
        integers.add(1);
        integers.add(2);
        integers.add(3);
 
        /**添加到指定位置*/
        integers.add(0, 0);
        /**修改指定位置值*/
        integers.set(0, -1);
        /**取索引位置值*/
        Integer integer = integers.get(0);
        /**列表索引从0开始*/
        int i0 = integers.indexOf(-1);
        int i3 = integers.indexOf(3);
 
        System.out.println("index:0:" + integer);
        System.out.println("index:-1:index:" + i0);
        System.out.println("elem:3:index:" + i3);
 
        integers.forEach(p -> {
            System.out.println(p);
        });
    }
 
    /**
     * 对象类型放入列表，当使用indexOf和Contains方法必须实现对应equals方法
     */
    @Test
    public void testObjList() {
        ArrayList<Demo> demos = new ArrayList<>();
        demos.add(new Demo(1, "binfire"));
        demos.add(new Demo(2, "shanshan"));
 
        Demo demo = new Demo(2, "yuxuan");
        int i = demos.indexOf(demo);
        boolean contains = demos.contains(demo);
 
        System.out.printf("index:%d,exists；%b", i, contains);
    }
 
    /**
     * %s:字符串 %c 字符 %b 布尔值 %x 16进制  %o 8进制 %d%% 百分笔  %n换行
     */
    @Test
    void testPrintf() {
        System.out.printf("%s;%c;%b;%d;%x;%o;%f;%d%%;%n", "china", 'i', true, 10, 100, 100, 99.9, 85);
        String a = "191328015";
        if (a == "191328015") {
            System.out.printf("ok");
        } else {
            System.out.printf("error");
        }
 
    }
 
    @Test
    void testLinkList() {
        LinkedList<Integer> integers = new LinkedList<>();
        integers.add(1);
        integers.add(2);
        integers.add(3);
        integers.addFirst(0);
        integers.addLast(4);
 
        System.out.printf("%d%n", integers.getFirst());
        System.out.printf("%d%n", integers.getLast());
        System.out.printf("%d%n", integers.get(1));
 
        integers.removeFirst();
        integers.removeLast();
 
        System.out.println(integers.toString());
    }
 
    /**
     * 模拟堆栈  linkedList.push  linkedList.pop
     */
    @Test
    void testStack() {
        LinkedList<Integer> integers = new LinkedList<>();
        integers.push(1);
        integers.push(2);
        integers.push(3);
 
        while (integers.size() > 0) {
            System.out.println(integers.pop());
        }
    }
 
    /**
     * 模拟队列 linkedList.offer linkedList.poll
     */
    @Test
    void testQueue() {
        LinkedList<Integer> integers2 = new LinkedList<>();
        integers2.offer(1);
        integers2.offer(2);
        integers2.offer(3);
 
        while (integers2.size() > 0) {
            System.out.println(integers2.poll());
        }
    }
 
    /**
     * 首先计算HashCode，再计算equals方法
     */
    @Test
    void testHashSet() {
        HashSet<Demo> demos = new HashSet<>();
        demos.add(new Demo(1, "binfire"));
        demos.add(new Demo(2, "yuxuan"));
        boolean shanshan = demos.add(new Demo(1, "shanshan"));
        System.out.printf("can add %b%n", shanshan);
        System.out.println(demos.toString());
 
        HashSet<String> strings = new HashSet<>();
        strings.add("binfire");
        strings.add("yuxuan");
        boolean binfire = strings.add("binfire");
        System.out.println("can add :" + binfire);
        System.out.println(strings.toString());
    }
 
    /**
     * 比较实现Comparable<T>接口, 重复则不添加
     */
    @Test
    void testTreeSet() {
        TreeSet<Integer> set = new TreeSet<>();
        set.add(1);
        set.add(9);
        set.add(8);
        set.add(7);
        set.add(6);
        set.add(5);
        set.add(1);
        System.out.println(set.toString());
 
        /**Demo继承Comparator*/
        TreeSet<Demo> demos = new TreeSet<>();
        demos.add(new Demo(1, "binfire"));
        demos.add(new Demo(2, "shanshan"));
        demos.add(new Demo(3, "yuxuan"));
        demos.add(new Demo(1, "xiaohong"));
 
        System.out.println(demos.toString());
 
        /**自定义比较器*/
        TreeSet<Demo> demos1 = new TreeSet<>(new Comparator<Demo>() {
            @Override
            public int compare(Demo o1, Demo o2) {
                return o1.id - o2.id;
            }
        });
        demos1.add(new Demo(1, "binfire"));
        demos1.add(new Demo(2, "shanshan"));
        demos1.add(new Demo(3, "yuxuan"));
        demos1.add(new Demo(1, "xiaohong"));
        System.out.println(demos1.toString());
 
    }
 
    @Test
    void testHashMap() {
        Map<Integer, String> integerStringHashMap = new HashMap<Integer, String>();
        integerStringHashMap.put(1, "binfire");
        integerStringHashMap.put(2, "shanshan");
        String yuxuan = integerStringHashMap.put(1, "yuxuan");  /*相同key则覆盖*/
        System.out.println(yuxuan);
        System.out.println(integerStringHashMap.toString());
        String binfire = integerStringHashMap.put(3, "binfire");
        System.out.println(binfire + "空");
 
        //integerStringHashMap.entrySet().for
        for (Map.Entry<Integer, String> integerStringEntry : integerStringHashMap.entrySet()) {
            System.out.println(integerStringEntry.getKey() + ":" + integerStringEntry.getValue());
        }
 
        HashMap<Demo, String> demoStringHashMap = new HashMap<>();
        demoStringHashMap.put(new Demo(1, "binfier001"), "001");
        demoStringHashMap.put(new Demo(2, "binfier002"), "002");
        demoStringHashMap.put(new Demo(1, "binfier003"), "003");
 
        for (Map.Entry<Demo, String> demoStringEntry : demoStringHashMap.entrySet()) {
            System.out.println(demoStringEntry.getKey() + ":" + demoStringEntry.getValue());
        }
    }
 
    @Test
    void testTreeMap() {
        TreeMap<Demo, String> demoStringTreeMap = new TreeMap<>(new Comparator<Demo>() {
            @Override
            public int compare(Demo o1, Demo o2) {
                return o1.id-o2.id;
            }
        });
        demoStringTreeMap.put(new Demo(1,"binfire001"),"001");
        demoStringTreeMap.put(new Demo(2,"binfire002"),"002");
        demoStringTreeMap.put(new Demo(1,"binfire001"),"003");
 
        for (Map.Entry<Demo, String> demoStringEntry : demoStringTreeMap.entrySet()) {
            System.out.println("key="+demoStringEntry.getKey().toString()+";value="+demoStringEntry.getValue());
        }
    }
 
 
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @Accessors(chain = true)
    class Demo implements Comparable<Demo> {
        private int id;
        private String name;
 
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof Demo)) return false;
            Demo demo = (Demo) o;
            return id == demo.id;
        }
 
        @Override
        public int hashCode() {
            return Objects.hash(id);
        }
 
        @Override
        public int compareTo(Demo o) {
            return this.id - o.id;
        }
 
        @Override
        public String toString() {
            return "Demo{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    '}';
        }
    }
 
}