{"id":7244,"date":"2023-10-02T21:04:02","date_gmt":"2023-10-02T20:04:02","guid":{"rendered":"https:\/\/www.baeldung.com\/java-arrays-sort-vs-collections-sort"},"modified":"2023-10-02T21:04:02","modified_gmt":"2023-10-02T20:04:02","slug":"difference-between-arrays-sort-and-collections-sort","status":"publish","type":"post","link":"https:\/\/gamefootballmobileanimeiphone.com\/index.php\/2023\/10\/02\/difference-between-arrays-sort-and-collections-sort\/","title":{"rendered":"Difference Between Arrays.sort() and Collections.sort()"},"content":{"rendered":"

\"\"<\/p>\n

1. Overview<\/h2>\n
<\/div>\n

Sorting<\/a> is a fundamental operation in computer science, essential for data organization and manipulation across various applications.<\/p>\n

In this tutorial, we’ll compare Java’s commonly used sorting methods: Arrays.sort()<\/em> and Collections.sort()<\/em>. While serving the same primary function\u2014sorting data\u2014each method has its own features, caveats, and optimal use cases.<\/p>\n

2. Basic Overview<\/h2>\n
<\/div>\n

Let’s begin by examining the fundamental differences between these two methods.<\/p>\n

2.1. Arrays.sort()<\/em><\/h3>\n
<\/div>\n

The Arrays.sort()<\/em> method is a utility function for sorting arrays in Java.<\/strong> It allows to sort arrays of primitive data types and objects. Whether we’re working with numerical data or alphabetical strings, Arrays.sort()<\/em> can arrange the elements in ascending order. Additionally, we can modify the behavior with custom comparators for object arrays. This method is part of the java.util.Arrays<\/em><\/a> class, which provides a suite of utilities for array manipulation.<\/p>\n

2.2. Collections.sort()<\/em><\/h3>\n
<\/div>\n

On the other hand, Collections.sort()<\/em> is designed for sorting instances of the List<\/em> interface in Java’s Collection Framework.<\/strong> Unlike Arrays.sort()<\/em>, which is limited to arrays, Collections.sort()<\/em> can sort more dynamic data structures like ArrayList<\/em><\/a>, LinkedList<\/em><\/a>, and other classes that implement the List<\/em><\/a> interface. Collections.sort()<\/em> is a member of the java.util.Collections<\/em> class, a utility class filled with static methods for operating on collections.<\/p>\n

3. Stability<\/h2>\n
<\/div>\n

Let’s imagine that we have a collection of tasks:<\/p>\n

tasks = new ArrayList<>();\r\ntasks.add(new Task(1, 1, "2023-09-01"));\r\ntasks.add(new Task(2, 2, "2023-08-30"));\r\ntasks.add(new Task(3, 1, "2023-08-29"));\r\ntasks.add(new Task(4, 2, "2023-09-02"));\r\ntasks.add(new Task(5, 3, "2023-09-05"));\r\ntasks.add(new Task(6, 1, "2023-09-03"));\r\ntasks.add(new Task(7, 3, "2023-08-28"));\r\ntasks.add(new Task(8, 2, "2023-09-01"));\r\ntasks.add(new Task(9, 1, "2023-08-28"));\r\ntasks.add(new Task(10, 2, "2023-09-04"));\r\ntasks.add(new Task(11, 3, "2023-08-31"));\r\ntasks.add(new Task(12, 1, "2023-08-30"));\r\ntasks.add(new Task(13, 3, "2023-09-02"));<\/code><\/pre>\n
We would like to sort them first by their priority and then by their due date. We’ll be sorting them with two different approaches. In the first case, we’ll be using a stable algorithm<\/a> provided by Collections<\/em>:<\/p>\n
final List<Task> tasks = Tasks.supplier.get();\r\nCollections.sort(tasks, Comparator.comparingInt(Task::getPriority));\r\nSystem.out.println("After sorting by priority:");\r\nfor (Task task : tasks) {\r\n    System.out.println(task);\r\n}\r\nCollections.sort(tasks, Comparator.comparing(Task::getDueDate));\r\nSystem.out.println("\\nAfter sorting by due date:");\r\nfor (Task task : tasks) {\r\n    System.out.println(task);\r\n}<\/code><\/pre>\n
Also, we’ll sort the tasks using a non-stable algorithm. Because Java doesn’t offer the option to sort a List of reference types using a non-stable algorithm, we have a simple implementation of quicksort:<\/p>\n
List<Task> tasks = Tasks.supplier.get();\r\nquickSort(tasks, Comparator.comparingInt(Task::getPriority));\r\nSystem.out.println("After sorting by priority:");\r\nfor (Task task : tasks) {\r\n    System.out.println(task);\r\n}\r\nquickSort(tasks, Comparator.comparing(Task::getDueDate));\r\nSystem.out.println("\\nAfter sorting by due date:");\r\nfor (Task task : tasks) {\r\n    System.out.println(task);\r\n}\r\n<\/code><\/pre>\n
The code is overall the same. The only difference is the algorithms used. The sorting is happening in two steps. The first step sorts the tasks by priority and the second by due date.<\/p>\n
The difference in the results is subtle but might significantly affect the code’s functionality and introduce hard-to-debug bugs. The stable version produces the following output:<\/p>\n
After sorting by due date:\r\nTask: #9  | Priority: 1 | Due Date: 2023-08-28\r\nTask: #7  | Priority: 3 | Due Date: 2023-08-28\r\nTask: #3  | Priority: 1 | Due Date: 2023-08-29\r\nTask: #12 | Priority: 1 | Due Date: 2023-08-30\r\nTask: #2  | Priority: 2 | Due Date: 2023-08-30\r\nTask: #11 | Priority: 3 | Due Date: 2023-08-31\r\nTask: #1  | Priority: 1 | Due Date: 2023-09-01\r\nTask: #8  | Priority: 2 | Due Date: 2023-09-01\r\nTask: #4  | Priority: 2 | Due Date: 2023-09-02\r\nTask: #13 | Priority: 3 | Due Date: 2023-09-02\r\nTask: #6  | Priority: 1 | Due Date: 2023-09-03\r\nTask: #10 | Priority: 2 | Due Date: 2023-09-04\r\nTask: #5  | Priority: 3 | Due Date: 2023-09-05<\/code><\/pre>\n
The tasks are sorted by date, and the previous ordering by priority will be saved when the dates are the same. Whereas the non-stable version gives us this:<\/p>\n
After sorting by due date:\r\nTask: #9  | Priority: 1 | Due Date: 2023-08-28\r\nTask: #7  | Priority: 3 | Due Date: 2023-08-28\r\nTask: #3  | Priority: 1 | Due Date: 2023-08-29\r\nTask: #2  | Priority: 2 | Due Date: 2023-08-30\r\nTask: #12 | Priority: 1 | Due Date: 2023-08-30\r\nTask: #11 | Priority: 3 | Due Date: 2023-08-31\r\nTask: #1  | Priority: 1 | Due Date: 2023-09-01\r\nTask: #8  | Priority: 2 | Due Date: 2023-09-01\r\nTask: #4  | Priority: 2 | Due Date: 2023-09-02\r\nTask: #13 | Priority: 3 | Due Date: 2023-09-02\r\nTask: #6  | Priority: 1 | Due Date: 2023-09-03\r\nTask: #10 | Priority: 2 | Due Date: 2023-09-04\r\nTask: #5  | Priority: 3 | Due Date: 2023-09-05<\/code><\/pre>\n
The tasks #2 and #12 have the same due date, but the priority is inversed. This is because a non-stable algorithm produces a non-deterministic behavior when it deals with equal but distinguishable items<\/a>.<\/strong><\/p>\n
Because primitives don’t have identity or additional parameters, we can sort them using a non-stable algorithm.<\/strong> The only thing they have is a value, and that’s why we don’t care about the stability of the algorithms we’re using for primitives. As the example above shows, the stability feature is crucial for sorting objects.<\/p>\n
That’s why Arrays.sort()<\/em> uses the same implementation of a non-stable algorithm for primitives, such as Quicksort<\/a> or Dual-Pivot Quicksort. When dealing with the collections of reference types, both Arrays.sort()<\/em> and Collections.sort()<\/em> use the same implementation, usually Merge Sort<\/a> or TimSort<\/a>.<\/strong><\/p>\n
4. Complexity<\/h2>\n
<\/div>\n
Let’s make a simple example comparing Merge Sort and Quicksort to show the difference between these algorithms and eventually between Collections.sort()<\/em>\u00a0and\u00a0Arrays.sort()<\/em>. We’ll be using simple implementations for both of them.<\/strong> This is done partially because Java doesn’t provide these algorithms, so we can pick them directly, and partly because the current algorithms have too many tweaks and improvements. Hence, it’s hard to develop similar test cases for both of them.<\/p>\n
We will run the following tests to compare the throughput:<\/p>\n
@Measurement(iterations = 2, time = 10, timeUnit = TimeUnit.MINUTES)\r\n@Warmup(iterations = 5, time = 10)\r\npublic class PerformanceBenchmark {\r\n    private static final Random RANDOM = new Random();\r\n    private static final int ARRAY_SIZE = 10000;\r\n    private static final int[] randomNumbers = RANDOM.ints(ARRAY_SIZE).toArray();\r\n    private static final int[] sameNumbers = IntStream.generate(() -> 42).limit(ARRAY_SIZE).toArray();\r\n    public static final Supplier<int[]> randomNumbersSupplier = randomNumbers::clone;\r\n    public static final Supplier<int[]> sameNumbersSupplier = sameNumbers::clone;\r\n    @Benchmark\r\n    @BenchmarkMode(Mode.Throughput)\r\n    @Fork(value = 1, jvmArgs = {"-Xlog:gc:file=gc-logs-quick-sort-same-number-%t.txt,filesize=900m -Xmx6gb -Xms6gb"})\r\n    public void quickSortSameNumber() {\r\n        Quicksort.sort(sameNumbersSupplier.get());\r\n    }\r\n    @Benchmark\r\n    @BenchmarkMode(Mode.Throughput)\r\n    @Fork(value = 1, jvmArgs = {"-Xlog:gc:file=gc-logs-quick-sort-random-number-%t.txt,filesize=900m -Xmx6gb -Xms6gb"})\r\n    public void quickSortRandomNumber() {\r\n        Quicksort.sort(randomNumbersSupplier.get());\r\n    }\r\n    @Benchmark\r\n    @BenchmarkMode(Mode.Throughput)\r\n    @Fork(value = 1, jvmArgs = {"-Xlog:gc:file=gc-logs-merge-sort-same-number-%t.txt,filesize=900m -Xmx6gb -Xms6gb"})\r\n    public void mergeSortSameNumber() {\r\n        MergeSort.sort(sameNumbersSupplier.get());\r\n    }\r\n    @Benchmark\r\n    @BenchmarkMode(Mode.Throughput)\r\n    @Fork(value = 1, jvmArgs = {"-Xlog:gc:file=gc-logs-merge-sort-random-number-%t.txt,filesize=900m -Xmx6gb -Xms6gb"})\r\n    public void mergeSortRandomNumber() {\r\n        MergeSort.sort(randomNumbersSupplier.get());\r\n    }\r\n}<\/code><\/pre>\n
After running these tests, we got two artifacts: one is the performance metrics, and the other one is the garbage collection log.<\/p>\n
4.1. Time Complexity<\/h3>\n
<\/div>\n
Let’s review the performance metrics for the tests above:<\/p>\n
Benchmark                                    Mode  Cnt     Score     Error  Units\r\nPerformanceBenchmark.mergeSortRandomNumber  thrpt    4  1489.983 \u00b1 401.330  ops\/s\r\nPerformanceBenchmark.quickSortRandomNumber  thrpt    4  2757.273 \u00b1  29.606  ops\/s<\/code><\/pre>\n
Firstly, using Quicksort to sort random numbers, in general, is almost twice as fast as the MergeSort.<\/strong> The fact that Quicksort happens in place reduces the space complexity affecting the performance, which we discuss in the next section.<\/p>\n
Also, we can see that Quicksort may degrade quite rapidly in some cases:<\/p>\n
Benchmark                                    Mode  Cnt     Score     Error  Units\r\nPerformanceBenchmark.mergeSortSameNumber    thrpt    4  5295.502 \u00b1  98.624  ops\/s\r\nPerformanceBenchmark.quickSortSameNumber    thrpt    4   118.211 \u00b1   0.117  ops\/s<\/code><\/pre>\n
For example, when all the numbers are the same, MergeSort performs much better and is blazingly fast. Although we’re using a simple implementation of Quicksort and MergeSort, the behavior is generally similar to their more optimized and complex counterparts.\u00a0\u00a0<\/strong><\/p>\n
Please keep in mind that the performance of an algorithm and its time complexity might not correlate as there are many things we should consider additional: space complexity, hidden constant factors, optimization, adaptivity<\/a>, etc.<\/p>\n
The upper bound<\/a> for the Quicksort and Dual-Pivot Quicksort is higher<\/a> than MergeSort or TimSort. <\/strong>However, due to a series of improvements and checks, performance issues are rendered negligible and, overall, can be ignored. Thus, we can assume that Merge Sort, TimSort, Quicksort, and Dual-Pivot Quicksort would have the same time complexity.<\/strong><\/p>\n
DualPivotQuicksort.sort() method, for example, considers many parameters, such as parallelization, array size, presorted runs, and even the recursion depth. Depending on the primitive types and the size of an array, Java can use different algorithms, like Insertion Sort<\/a> or Counting Sort<\/a>. That’s why it’s hard to compare highly optimized algorithms; they would generally produce similar results.<\/p>\n
4.2. Space Complexity<\/h3>\n
<\/div>\n
As mentioned previously, while being non-stable, Quicksort and Dual-Pivot Quicksort algorithms\u00a0come with a trade-off as they use less space.<\/strong> Depending on the implementation, they might have at most O(log*n) space complexity. This is a nice feature that might have a significant performance impact. In our case, let’s concentrate on sorting random numbers.<\/p>\n
While the time complexity of these algorithms is considered roughly the same, we have dramatic differences in the performance:<\/p>\n
Benchmark                                    Mode  Cnt     Score     Error  Units\r\nPerformanceBenchmark.mergeSortRandomNumber  thrpt    4  1489.983 \u00b1 401.330  ops\/s\r\nPerformanceBenchmark.quickSortRandomNumber  thrpt    4  2757.273 \u00b1  29.606  ops\/s<\/code><\/pre>\n
To investigate this difference, we could look at the garbage collection logs. We’ll be using IBM Garbage Collection and Memory Visualizer:<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Variant<\/td>\nmergeSort<\/td>\nquickSort<\/td>\n<\/tr>\n
Forced collection count<\/td>\n0<\/td>\n0<\/td>\n<\/tr>\n
Full collections<\/td>\n0<\/td>\n0<\/td>\n<\/tr>\n
GC Mode<\/td>\nG1<\/td>\nG1<\/td>\n<\/tr>\n
Mean garbage collection pause (ms)<\/td>\n0.33<\/td>\n0.47<\/td>\n<\/tr>\n
Number of collections triggered by allocation failure<\/td>\n26848<\/td>\n588<\/td>\n<\/tr>\n
Proportion of time spent in garbage collection pauses (%)<\/td>\n0.72<\/td>\n0.02<\/td>\n<\/tr>\n
Proportion of time spent in stop-the-world garbage collection pauses (%)<\/td>\n0.72<\/td>\n0.02<\/td>\n<\/tr>\n
Proportion of time spent unpaused (%)<\/td>\n99.28<\/td>\n99.98<\/td>\n<\/tr>\n
Young collections – Mean garbage collection pause (ms)<\/td>\n0.33<\/td>\n0.47<\/td>\n<\/tr>\n
Young collections – Mean interval between collections (ms)<\/td>\n46.6<\/td>\n2124<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
As we can see, the number of garbage collection events is significantly higher for MergeSort (26848 vs. 588), and it’s understandable as this algorithm uses more space.<\/p>\n
4.3. Optimization<\/h3>\n
<\/div>\n
Because Merge Sort and TimSort require more space, using a non-stable algorithm for primitives is the optimization step, assuming that Quicksort and Dual-Pivot Quicksort degradation to O(n^2) is negligible. Technically, it’s possible to use a non-stable sorting algorithm for a collection of reference types and get a boost in performance. This can be done if stability isn’t important or equal objects are non-distinguishable.<\/strong><\/p>\n
One of the improvements we can use for wrapper classes is to convert them into primitives, do the sorting, and convert them back. Let’s consider the following test:<\/p>\n
@Measurement(iterations = 2, time = 10, timeUnit = TimeUnit.MINUTES)\r\n@Warmup(iterations = 5, time = 10)\r\n@Fork(value = 2)\r\npublic class ObjectOverheadBenchmark {\r\n    private static final ThreadLocalRandom RANDOM = ThreadLocalRandom.current();\r\n    @State(Scope.Benchmark)\r\n    public static class Input {\r\n        public Supplier<List<Integer>> randomNumbers = () -> RANDOM.ints().limit(10000).boxed().collect(Collectors.toList());\r\n    }\r\n    @Benchmark\r\n    @BenchmarkMode(Mode.Throughput)\r\n    public void sortingPrimitiveArray(Input input, Blackhole blackhole) {\r\n        final int[] array = input.randomNumbers.get().stream().mapToInt(Integer::intValue).toArray();\r\n        Arrays.sort(array);\r\n        final List<Integer> result = Arrays.stream(array).boxed().collect(Collectors.toList());\r\n        blackhole.consume(result);\r\n    }\r\n    @Benchmark\r\n    @BenchmarkMode(Mode.Throughput)\r\n    public void sortingObjectArray(Input input, Blackhole blackhole) {\r\n        final Integer[] array = input.randomNumbers.get().toArray(new Integer[0]);\r\n        Arrays.sort(array);\r\n        blackhole.consume(array);\r\n    }\r\n    \r\n    @Benchmark\r\n    @BenchmarkMode(Mode.Throughput)\r\n    public void sortingObjects(Input input, Blackhole blackhole) {\r\n        final List<Integer> list = input.randomNumbers.get();\r\n        Collections.sort(list);\r\n        blackhole.consume(list);\r\n    }\r\n}<\/code><\/pre>\n
The fact that we’re using\u00a0Arrays.sort()<\/em> here significantly boosts our performance\u00a0Collection.sort():<\/em><\/p>\n
Benchmark                                       Mode  Cnt     Score     Error  Units\r\nObjectOverheadBenchmark.sortingObjectArray     thrpt    4   982.849 \u00b1  19.201  ops\/s\r\nObjectOverheadBenchmark.sortingObjects         thrpt    4   976.778 \u00b1  10.580  ops\/s\r\nObjectOverheadBenchmark.sortingPrimitiveArray  thrpt    4  1998.818 \u00b1 373.654  ops\/s<\/code><\/pre>\n
Sorting an\u00a0int[]<\/em> produces more than a 100% increase in performance.<\/p>\n
5. Implementation Details of Arrays.sort()<\/em> and Collections.sort()<\/em><\/h2>\n
<\/div>\n
Please note that the algorithms and tests used in the previous sections. They don’t reflect the library implementation’s performance, as they have more complex processes that allow them to optimize specific cases.<\/strong> The tests are presented only to provide more visual information about the inner workings of the simple implementation for these two kinds of algorithms.<\/p>\n
It’s virtually impossible to compare Collections.sort()\u00a0<\/em>and\u00a0Arrays.sort()<\/em> without their underlying algorithms.<\/p>\n
The underlying algorithms are the crucial part contributing to these two methods’ complexity and performance.<\/strong>\u00a0Because\u00a0Collections.sort()<\/em> is implemented with stability in mind, they use Merge Sort or TimSort. At the same time, sorting primitives doesn’t require this property and can use Quicksort or Dual-Pivot Quicksort.<\/p>\n
To better understand these methods, we looked at the sorting algorithms they use directly.<\/p>\n
6. Conclusion<\/h2>\n
<\/div>\n
Sorting is one of the cornerstone operations in computer science, enabling efficient data manipulation across many applications. By understanding the differences between algorithms, we can make more informed decisions when coding and optimizing for performance and functionality according to your specific requirements.<\/p>\n
Thus, although this article aims to highlight the difference between Collections.sort()\u00a0<\/em>and\u00a0Arrays.sort().\u00a0<\/em>It is also a great guide to understanding the differences between different sorting algorithms.\u00a0As always, the code for the implementation of this algorithm can be found over\u00a0on GitHub<\/a>.<\/p>\n
\"\"<\/p>\n
<\/a> <\/a> <\/a> <\/a> <\/a> <\/a> <\/a> <\/div>\n\n
Commercials Cooperation Advertisements:<\/b><\/h2>\r\n

(1) IT Teacher IT Freelance
 <\/p>\r\nIT\u96fb\u8166\u88dc\u7fd2<\/a>
\u7acb\u523b\u8a3b\u518a\u53ca\u5831\u540d\u96fb\u8166\u88dc\u7fd2\u8ab2\u7a0b\u5427! <\/a>
\r\n\r\n\u7535\u5b50\u8ba1\u7b97\u673a -\u6559\u80b2 -IT \u96fb\u8166\u73ed\u201d ( IT\u96fb\u8166\u88dc\u7fd2 ) \u63d0\u4f9b\u4e00\u500b\u65b9\u4fbf\u7684\u7535\u5b50\u8ba1\u7b97\u673a \u6559\u80b2\u5e73\u53f0, \u70ba\u5927\u5bb6\u914d\u5c0d\u4fe1\u606f\u6280\u672f, \u96fb\u8166 \u8001\u5e2b, IT freelance \u548c programming expert. \u8b93\u5927\u5bb6\u65b9\u4fbf\u5730\u5c31\u80fd\u627e\u5230\u5408\u9069\u7684\u96fb\u8166\u88dc\u7fd2, \u96fb\u8166\u73ed, \u5bb6\u6559, \u79c1\u4eba\u8001\u5e2b.  
\r\n\r\nWe are a education and information platform which you can find a IT private tutorial teacher or freelance. 
\r\n\r\nAlso we provide different information about information technology, Computer, programming, mobile, Android, apple, game, movie, anime, animation\u2026 \r\n<\/p>\n

(2) ITSec
 <\/p>https:\/\/itsec.vip\/\r\nSecure<\/a> \r\n

 \r\n
www.ITSec.vip<\/a> 
 
 \r\n
www.Sraa.com.hk<\/a> 
 
 \r\n
www.ITSec.hk<\/a> 
 
 \r\n
www.Penetrationtest.hk<\/a> 
 
 \r\n
www.ITSeceu.uk<\/a> 
 
 \r\nSecure Your Computers from Cyber Threats and mitigate risks with professional services to defend Hackers. 

\r\nITSec provide IT Security and Compliance Services, including IT Compliance Services, Risk Assessment, IT Audit, Security Assessment and Audit, ISO 27001 Consulting and Certification, GDPR Compliance Services, Privacy Impact Assessment (PIA), Penetration test, Ethical Hacking, Vulnerabilities scan, IT Consulting, Data Privacy Consulting, Data Protection Services, Information Security Consulting, Cyber Security Consulting, Network Security Audit, Security Awareness Training. \r\n

Contact us right away. 

Email (Prefer using email to contact us): 
SalesExecutive@ITSec.vip<\/p>","protected":false},"excerpt":{"rendered":"
\"\"<\/p>\n
Compare two Java’s commonly used sorting methods: Arrays.sort() and Collections.sort().<\/p>\n
<\/a>\u00a0<\/a>\u00a0<\/a>\u00a0<\/a>\u00a0<\/a>\u00a0<\/a>\u00a0<\/a>\u00a0<\/div>\n","protected":false},"author":291,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"site-container-style":"default","site-container-layout":"default","site-sidebar-layout":"default","disable-article-header":"default","disable-site-header":"default","disable-site-footer":"default","disable-content-area-spacing":"default","footnotes":""},"categories":[22],"tags":[61,122,127,129,124,128,125,132,131,133,126,130,123,66,94,88,97,56,64,65,60,112,40,75,95,104,33,120,105,101,98,115,30,29,41,86,70,69,68,72,71,26,118,108,87,46,55,48,52,54,51,50,83,62,58,57,109,35,59,63,85,79,82,96,80,27,81,114,44,42,43,45,38,39,110,117,100,111,116,73,89,90,92,91,93,84,78,37,102,34,36,77,67,74,99,113,119,28,121,32,47,49,53,103,31,76],"class_list":["post-7244","post","type-post","status-publish","format-standard","hentry","category-mobile","tag-airpods","tag-anime","tag-anime-characters","tag-anime-cosplay","tag-anime-edits","tag-anime-merchandise","tag-anime-movies","tag-anime-news","tag-anime-recommendations","tag-anime-reviews","tag-anime-series","tag-anime-streaming","tag-animes","tag-app-store","tag-app-store-samsung","tag-appgallery","tag-appgallery-oneplus","tag-apple","tag-apple-music","tag-apple-tv","tag-apple-watch","tag-bbc-sport","tag-best-mobile-games","tag-bixby","tag-bixby-xiaomi","tag-champions-league","tag-cyberpunk","tag-cyberpunk-2077","tag-fantasy-football","tag-fifa","tag-football","tag-formula-1","tag-fortnite","tag-free-fire","tag-free-mobile-games","tag-freebuds-pro","tag-galaxy-a52","tag-galaxy-note-20","tag-galaxy-s21","tag-galaxy-watch-4","tag-galaxy-z-fold-3","tag-game","tag-games","tag-golf","tag-harmonyos","tag-how-to-backup-iphone","tag-how-to-factory-reset-iphone","tag-how-to-reset-iphone","tag-how-to-restore-iphone","tag-how-to-unlock-iphone","tag-how-to-unlock-iphone-5","tag-how-to-unlock-iphone-6","tag-huawei","tag-ios","tag-ipad","tag-iphone","tag-live-soccer","tag-lol","tag-macbook","tag-macos","tag-mate-40-pro","tag-mi-11-lite","tag-mi-home-security-camera-basic-1080p","tag-mi-home-security-camera-basic-1080p-huawei","tag-mi-smart-band-6","tag-minecraft","tag-miui","tag-mlb-scores","tag-mobile-game-design","tag-mobile-game-development","tag-mobile-game-marketing","tag-mobile-game-monetization","tag-mobile-games","tag-mobile-gaming","tag-nba-scores","tag-nba-standings","tag-nfl","tag-nfl-scores","tag-nhl-scores","tag-one-ui","tag-oneplus","tag-oneplus-9-pro","tag-oneplus-buds-pro","tag-oneplus-nord-ce-5g","tag-oxygenos","tag-p40-pro-plus","tag-poco-x3-pro","tag-pokemon","tag-premier-league","tag-pubg","tag-pubg-mobile","tag-redmi-note-10-pro","tag-samsung","tag-samsung-pay","tag-soccer","tag-sports","tag-steam","tag-steeam","tag-top-10-anime","tag-valorant","tag-when-do-the-iphone-7-come-out","tag-when-does-the-iphone-7-come-out","tag-when-is-the-iphone-7-coming-out","tag-world-cup","tag-xbox-series-x","tag-xiaomi"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/gamefootballmobileanimeiphone.com\/index.php\/wp-json\/wp\/v2\/posts\/7244","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/gamefootballmobileanimeiphone.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/gamefootballmobileanimeiphone.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/gamefootballmobileanimeiphone.com\/index.php\/wp-json\/wp\/v2\/users\/291"}],"replies":[{"embeddable":true,"href":"https:\/\/gamefootballmobileanimeiphone.com\/index.php\/wp-json\/wp\/v2\/comments?post=7244"}],"version-history":[{"count":1,"href":"https:\/\/gamefootballmobileanimeiphone.com\/index.php\/wp-json\/wp\/v2\/posts\/7244\/revisions"}],"predecessor-version":[{"id":7245,"href":"https:\/\/gamefootballmobileanimeiphone.com\/index.php\/wp-json\/wp\/v2\/posts\/7244\/revisions\/7245"}],"wp:attachment":[{"href":"https:\/\/gamefootballmobileanimeiphone.com\/index.php\/wp-json\/wp\/v2\/media?parent=7244"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/gamefootballmobileanimeiphone.com\/index.php\/wp-json\/wp\/v2\/categories?post=7244"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/gamefootballmobileanimeiphone.com\/index.php\/wp-json\/wp\/v2\/tags?post=7244"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}