mjhjmtu

fdupes can do this. From man fdupes:

Searches the given path for duplicate files. Such files are found by comparing file sizes and MD5 signatures, followed by a byte-by-byte comparison.

In Debian or Ubuntu, you can install it with apt-get install fdupes. In Fedora/Red Hat/CentOS, you can install it with yum install fdupes. On Arch Linux you can use pacman -S fdupes, and on Gentoo, emerge fdupes.

To run a check descending from your filesystem root, which will likely take a significant amount of time and memory, use something like fdupes -r /.

As asked in the comments, you can get the largest duplicates by doing the following:

fdupes -r . | 
 while IFS= read -r file; do
 [[ $file ]] && du "$file"
 done
 | sort -n

This will break if your filenames contain newlines.

Another good tool is fslint:

fslint is a toolset to find various problems with filesystems,
including duplicate files and problematic filenames
etc.

Individual command line tools are available in addition to the GUI and to access them, one can change to, or add to
$PATH the /usr/share/fslint/fslint directory on a standard install. Each of these commands in that directory have a
--help option which further details its parameters.

 findup - find DUPlicate files

On debian-based systems, youcan install it with:

sudo apt-get install fslint

You can also do this manually if you don't want to or cannot install third party tools. The way most such programs work is by calculating file checksums. Files with the same md5sum almost certainly contain exactly the same data. So, you could do something like this:

find / -type f -exec md5sum ; > md5sums
gawk 'print $1' md5sums | sort | uniq -d > dupes
while read d; do echo "---"; grep $d md5sums | cut -d ' ' -f 2-; done < dupes 

Sample output (the file names in this example are the same, but it will also work when they are different):

$ while read d; do echo "---"; grep $d md5sums | cut -d ' ' -f 2-; done < dupes 
---
 /usr/src/linux-headers-3.2.0-3-common/include/linux/if_bonding.h
 /usr/src/linux-headers-3.2.0-4-common/include/linux/if_bonding.h
---
 /usr/src/linux-headers-3.2.0-3-common/include/linux/route.h
 /usr/src/linux-headers-3.2.0-4-common/include/linux/route.h
---
 /usr/src/linux-headers-3.2.0-3-common/include/drm/Kbuild
 /usr/src/linux-headers-3.2.0-4-common/include/drm/Kbuild
---

This will be much slower than the dedicated tools already mentioned, but it will work.

Short answer: yes.

Longer version: have a look at the wikipedia fdupes entry, it sports quite nice list of ready made solutions. Of course you can write your own, it's not that difficult - hashing programs like diff, sha*sum, find, sort and uniq should do the job. You can even put it on one line, and it will still be understandable.

If you believe a hash function (here MD5) is collision-free on your domain:

find $target -type f -exec md5sum '' + | sort | uniq --all-repeated --check-chars=32 
 | cut --characters=35-

Want identical file names grouped? Write a simple script not_uniq.sh to format output:

#!/bin/bash

last_checksum=0
while read line; do
 checksum=$line:0:32
 filename=$line:34
 if [ $checksum == $last_checksum ]; then
 if [ $last_filename:-0 != '0' ]; then
 echo $last_filename
 unset last_filename
 fi
 echo $filename
 else
 if [ $last_filename:-0 == '0' ]; then
 echo "======="
 fi
 last_filename=$filename
 fi

 last_checksum=$checksum
done

Then change find command to use your script:

chmod +x not_uniq.sh
find $target -type f -exec md5sum '' + | sort | not_uniq.sh

This is basic idea. Probably you should change find if your file names containing some characters. (e.g space)

I thought to add a recent enhanced fork of fdupes, jdupes, which promises to be faster and more feature rich than fdupes (e.g. size filter):

jdupes . -rS -X size-:50m > myjdups.txt

This will recursively find duplicated files bigger than 50MB in the current directory and output the resulted list in myjdups.txt.

Note, the output is not sorted by size and since it appears not to be build in, I have adapted @Chris_Down answer above to achieve this:

jdupes -r . -X size-:50m | 
 while IFS= read -r file; do
 [[ $file ]] && du "$file"
 done
 | sort -n > myjdups_sorted.txt

^{Wikipedia had an article (http://en.wikipedia.org/wiki/List_of_duplicate_file_finders), with a list of available open source software for this task, but it's now been deleted}.

I will add that the GUI version of fslint is very interesting, allowing to use mask to select which files to delete. Very useful to clean duplicated photos.

On Linux you can use:

- FSLint: http://www.pixelbeat.org/fslint/

- FDupes: https://en.wikipedia.org/wiki/Fdupes

- DupeGuru: https://www.hardcoded.net/dupeguru/

The 2 last work on many systems (windows, mac and linux) I 've not checked for FSLint

Here's my take on that:

find -type f -size +3M -print0 | while IFS= read -r -d '' i; do
 echo -n '.'
 if grep -q "$i" md5-partial.txt; then echo -e "n$i ---- Already counted, skipping."; continue; fi
 MD5=`dd bs=1M count=1 if="$i" status=noxfer | md5sum`
 MD5=`echo $MD5 | cut -d' ' -f1`
 if grep "$MD5" md5-partial.txt; then echo "n$i ---- Possible duplicate"; fi
 echo $MD5 $i >> md5-partial.txt
done

It's different in that it only hashes up to first 1 MB of the file.

This has few issues / features:

• There might be a difference after first 1 MB so the result rather a candidate to check. I might fix that later.


• Checking by file size first could speed this up.


• Only takes files larger than 3 MB.

I use it to compare video clips so this is enough for me.